file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/182952009.c | //
// Fusion-C
// example : arguments
//
//
//
// Call the program with command line arguments
// >argument test1 test2 test3
#include <stdio.h>
int main(char *argv[], int argc)
{
char i;
if (argc>1)
{
for ( i = 0; i < argc; ++i)
{
printf("Argument Numb %d passed : %s \n\r",i,argv[i]);
}
}
return(0);
} |
the_stack_data/198581272.c | //https://www.hackerrank.com/challenges/the-grid-search
// A Naive string brute force algorithm. Not even sure how it passed the cases without timing out.
#include<stdio.h>
int a[1005][1005];
int b[1005][1005];
int main() {
int t, i, j, k, l;
int r1, c1, r2, c2;
char inp[1005];
int globalFlag = 0;
int flag = 0;
scanf("%d", &t);
while (t--) {
globalFlag = 0;
for (i = 0; i < 1000; i++) {
for (j = 0; j < 1000; j++) {
a[i][j] = 0;
b[i][j] = 0;
}
inp[i] = '0';
}
scanf("%d%d", &r1, &c1);
for (i = 0; i < r1; i++) {
scanf("%s", inp);
for (j = 0; j < c1; j++) {
a[i][j] = inp[j] - '0';
}
}
scanf("%d%d", &r2, &c2);
for (i = 0; i < r2; i++) {
scanf("%s", inp);
for (j = 0; j < c2; j++) {
b[i][j] = inp[j] - '0';
}
}
if (r2 > r1 || c2 > c1) {
printf("NO\n");
continue;
}
for (i = 0; i < r1 - r2 + 1; i++) {
for (j = 0; j < c1 - c2 + 1; j++) {
flag = 0;
for (k = 0; k < r2; k++) {
for (l = 0; l < c2; l++) {
if (b[k][l] != a[i+k][j+l]) {
flag = 1;
break;
}
}
if (flag == 1) {
break;
}
}
if (flag == 0) {
globalFlag = 1;
break;
}
}
if (globalFlag == 1) {
break;
}
}
if (globalFlag == 1) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
|
the_stack_data/1154055.c | /* vi: set sw=4 ts=4: */
/* POSIX.2 wordexp implementation.
Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Tim Waugh <[email protected]>.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#define _GNU_SOURCE
#include <sys/cdefs.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pwd.h>
#include <errno.h>
#include <assert.h>
#include <fnmatch.h>
#include <glob.h>
#include <wordexp.h>
#define __WORDEXP_FULL
//#undef __WORDEXP_FULL
/*
* This is a recursive-descent-style word expansion routine.
*/
/* These variables are defined and initialized in the startup code. */
//extern int __libc_argc;
//extern char **__libc_argv;
/* FIXME!!!! */
int __libc_argc;
char **__libc_argv;
/* Some forward declarations */
static int parse_dollars(char **word, size_t * word_length,
size_t * max_length, const char *words,
size_t * offset, int flags, wordexp_t * pwordexp,
const char *ifs, const char *ifs_white,
int quoted);
static int parse_backtick(char **word, size_t * word_length,
size_t * max_length, const char *words,
size_t * offset, int flags, wordexp_t * pwordexp,
const char *ifs, const char *ifs_white);
static int parse_dquote(char **word, size_t * word_length,
size_t * max_length, const char *words,
size_t * offset, int flags, wordexp_t * pwordexp,
const char *ifs, const char *ifs_white);
/* The w_*() functions manipulate word lists. */
#define W_CHUNK (100)
/* Result of w_newword will be ignored if it's the last word. */
static inline char *w_newword(size_t * actlen, size_t * maxlen)
{
*actlen = *maxlen = 0;
return NULL;
}
/* Add a character to the buffer, allocating room for it if needed. */
static inline char *w_addchar(char *buffer, size_t * actlen,
size_t * maxlen, char ch)
/* (lengths exclude trailing zero) */
{
if (*actlen == *maxlen) {
char *old_buffer = buffer;
assert(buffer == NULL || *maxlen != 0);
*maxlen += W_CHUNK;
buffer = realloc(buffer, 1 + *maxlen);
if (buffer == NULL)
free(old_buffer);
}
if (buffer != NULL) {
buffer[*actlen] = ch;
buffer[++(*actlen)] = '\0';
}
return buffer;
}
#define MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )
static char *w_addmem(char *buffer, size_t * actlen, size_t * maxlen,
const char *str, size_t len)
{
/* Add a string to the buffer, allocating room for it if needed.
*/
if (*actlen + len > *maxlen) {
char *old_buffer = buffer;
assert(buffer == NULL || *maxlen != 0);
*maxlen += MAX(2 * len, W_CHUNK);
buffer = realloc(old_buffer, 1 + *maxlen);
if (buffer == NULL)
free(old_buffer);
}
if (buffer != NULL) {
*((char *) mempcpy(&buffer[*actlen], str, len)) = '\0';
*actlen += len;
}
return buffer;
}
/* Add a string to the buffer, allocating room for it if needed. */
static char *w_addstr(char *buffer, size_t * actlen, size_t * maxlen,
const char *str)
/* (lengths exclude trailing zero) */
{
size_t len;
assert(str != NULL); /* w_addstr only called from this file */
len = strlen(str);
return w_addmem(buffer, actlen, maxlen, str, len);
}
/* Add a word to the wordlist */
static int w_addword(wordexp_t * pwordexp, char *word)
{
size_t num_p;
char **new_wordv;
/* Internally, NULL acts like "". Convert NULLs to "" before
* the caller sees them.
*/
if (word == NULL) {
word = strdup("");
if (word == NULL)
goto no_space;
}
num_p = 2 + pwordexp->we_wordc + pwordexp->we_offs;
new_wordv = realloc(pwordexp->we_wordv, sizeof(char *) * num_p);
if (new_wordv != NULL) {
pwordexp->we_wordv = new_wordv;
pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc++] = word;
pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc] = NULL;
return 0;
}
no_space:
return WRDE_NOSPACE;
}
/* The parse_*() functions should leave *offset being the offset in 'words'
* to the last character processed.
*/
static int
parse_backslash(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset)
{
/* We are poised _at_ a backslash, not in quotes */
switch (words[1 + *offset]) {
case 0:
/* Backslash is last character of input words */
return WRDE_SYNTAX;
case '\n':
++(*offset);
break;
default:
*word = w_addchar(*word, word_length, max_length, words[1 + *offset]);
if (*word == NULL)
return WRDE_NOSPACE;
++(*offset);
break;
}
return 0;
}
static int
parse_qtd_backslash(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset)
{
/* We are poised _at_ a backslash, inside quotes */
switch (words[1 + *offset]) {
case 0:
/* Backslash is last character of input words */
return WRDE_SYNTAX;
case '\n':
++(*offset);
break;
case '$':
case '`':
case '"':
case '\\':
*word =
w_addchar(*word, word_length, max_length, words[1 + *offset]);
if (*word == NULL)
return WRDE_NOSPACE;
++(*offset);
break;
default:
*word = w_addchar(*word, word_length, max_length, words[*offset]);
if (*word != NULL)
*word =
w_addchar(*word, word_length, max_length,
words[1 + *offset]);
if (*word == NULL)
return WRDE_NOSPACE;
++(*offset);
break;
}
return 0;
}
static int
parse_tilde(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, size_t wordc)
{
/* We are poised _at_ a tilde */
size_t i;
if (*word_length != 0) {
if (!((*word)[*word_length - 1] == '=' && wordc == 0)) {
if (!((*word)[*word_length - 1] == ':'
&& strchr(*word, '=') && wordc == 0)) {
*word = w_addchar(*word, word_length, max_length, '~');
return *word ? 0 : WRDE_NOSPACE;
}
}
}
for (i = 1 + *offset; words[i]; i++) {
if (words[i] == ':' || words[i] == '/' || words[i] == ' ' ||
words[i] == '\t' || words[i] == 0)
break;
if (words[i] == '\\') {
*word = w_addchar(*word, word_length, max_length, '~');
return *word ? 0 : WRDE_NOSPACE;
}
}
if (i == 1 + *offset) {
/* Tilde appears on its own */
uid_t uid;
struct passwd pwd, *tpwd;
int buflen = 1000;
char *home;
char *buffer;
int result;
/* POSIX.2 says ~ expands to $HOME and if HOME is unset the
results are unspecified. We do a lookup on the uid if
HOME is unset. */
home = getenv("HOME");
if (home != NULL) {
*word = w_addstr(*word, word_length, max_length, home);
if (*word == NULL)
return WRDE_NOSPACE;
} else {
uid = getuid();
buffer = alloca(buflen);
while ((result = getpwuid_r(uid, &pwd, buffer, buflen, &tpwd))
!= 0 && errno == ERANGE)
{
buflen += 1000;
buffer = alloca(buflen);
}
if (result == 0 && tpwd != NULL && pwd.pw_dir != NULL) {
*word = w_addstr(*word, word_length, max_length, pwd.pw_dir);
if (*word == NULL)
return WRDE_NOSPACE;
} else {
*word = w_addchar(*word, word_length, max_length, '~');
if (*word == NULL)
return WRDE_NOSPACE;
}
}
} else {
/* Look up user name in database to get home directory */
char *user = strndup(&words[1 + *offset], i - (1 + *offset));
struct passwd pwd, *tpwd;
int buflen = 1000;
char *buffer = alloca(buflen);
int result;
while ((result = getpwnam_r(user, &pwd, buffer, buflen, &tpwd)) != 0
&& errno == ERANGE) {
buflen += 1000;
buffer = alloca(buflen);
}
if (result == 0 && tpwd != NULL && pwd.pw_dir)
*word = w_addstr(*word, word_length, max_length, pwd.pw_dir);
else {
/* (invalid login name) */
*word = w_addchar(*word, word_length, max_length, '~');
if (*word != NULL)
*word = w_addstr(*word, word_length, max_length, user);
}
*offset = i - 1;
}
return *word ? 0 : WRDE_NOSPACE;
}
static int
do_parse_glob(const char *glob_word, char **word, size_t * word_length,
size_t * max_length, wordexp_t * pwordexp, const char *ifs,
const char *ifs_white)
{
int error;
int match;
glob_t globbuf;
error = glob(glob_word, GLOB_NOCHECK, NULL, &globbuf);
if (error != 0) {
/* We can only run into memory problems. */
assert(error == GLOB_NOSPACE);
return WRDE_NOSPACE;
}
if (ifs && !*ifs) {
/* No field splitting allowed. */
assert(globbuf.gl_pathv[0] != NULL);
*word = w_addstr(*word, word_length, max_length, globbuf.gl_pathv[0]);
for (match = 1; match < globbuf.gl_pathc && *word != NULL; ++match) {
*word = w_addchar(*word, word_length, max_length, ' ');
if (*word != NULL)
*word = w_addstr(*word, word_length, max_length,
globbuf.gl_pathv[match]);
}
globfree(&globbuf);
return *word ? 0 : WRDE_NOSPACE;
}
assert(ifs == NULL || *ifs != '\0');
if (*word != NULL) {
free(*word);
*word = w_newword(word_length, max_length);
}
for (match = 0; match < globbuf.gl_pathc; ++match) {
char *matching_word = strdup(globbuf.gl_pathv[match]);
if (matching_word == NULL || w_addword(pwordexp, matching_word)) {
globfree(&globbuf);
return WRDE_NOSPACE;
}
}
globfree(&globbuf);
return 0;
}
static int
parse_glob(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs, const char *ifs_white)
{
/* We are poised just after a '*', a '[' or a '?'. */
int error = WRDE_NOSPACE;
int quoted = 0; /* 1 if singly-quoted, 2 if doubly */
int i;
wordexp_t glob_list; /* List of words to glob */
glob_list.we_wordc = 0;
glob_list.we_wordv = NULL;
glob_list.we_offs = 0;
for (; words[*offset] != '\0'; ++*offset) {
if ((ifs && strchr(ifs, words[*offset])) ||
(!ifs && strchr(" \t\n", words[*offset])))
/* Reached IFS */
break;
/* Sort out quoting */
if (words[*offset] == '\'') {
if (quoted == 0) {
quoted = 1;
continue;
} else if (quoted == 1) {
quoted = 0;
continue;
}
} else if (words[*offset] == '"') {
if (quoted == 0) {
quoted = 2;
continue;
} else if (quoted == 2) {
quoted = 0;
continue;
}
}
/* Sort out other special characters */
if (quoted != 1 && words[*offset] == '$') {
error = parse_dollars(word, word_length, max_length, words,
offset, flags, &glob_list, ifs,
ifs_white, quoted == 2);
if (error)
goto tidy_up;
continue;
} else if (words[*offset] == '\\') {
if (quoted)
error = parse_qtd_backslash(word, word_length, max_length,
words, offset);
else
error = parse_backslash(word, word_length, max_length,
words, offset);
if (error)
goto tidy_up;
continue;
}
*word = w_addchar(*word, word_length, max_length, words[*offset]);
if (*word == NULL)
goto tidy_up;
}
/* Don't forget to re-parse the character we stopped at. */
--*offset;
/* Glob the words */
error = w_addword(&glob_list, *word);
*word = w_newword(word_length, max_length);
for (i = 0; error == 0 && i < glob_list.we_wordc; i++)
error = do_parse_glob(glob_list.we_wordv[i], word, word_length,
max_length, pwordexp, ifs, ifs_white);
/* Now tidy up */
tidy_up:
wordfree(&glob_list);
return error;
}
static int
parse_squote(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset)
{
/* We are poised just after a single quote */
for (; words[*offset]; ++(*offset)) {
if (words[*offset] != '\'') {
*word = w_addchar(*word, word_length, max_length, words[*offset]);
if (*word == NULL)
return WRDE_NOSPACE;
} else
return 0;
}
/* Unterminated string */
return WRDE_SYNTAX;
}
#ifdef __WORDEXP_FULL
static int eval_expr(char *expr, long int *result);
static char *_itoa(unsigned long long int value, char *buflim)
{
sprintf(buflim, "%llu", value);
return buflim;
}
/* Functions to evaluate an arithmetic expression */
static int eval_expr_val(char **expr, long int *result)
{
int sgn = +1;
char *digit;
/* Skip white space */
for (digit = *expr; digit && *digit && isspace(*digit); ++digit);
switch (*digit) {
case '(':
/* Scan for closing paren */
for (++digit; **expr && **expr != ')'; ++(*expr));
/* Is there one? */
if (!**expr)
return WRDE_SYNTAX;
*(*expr)++ = 0;
if (eval_expr(digit, result))
return WRDE_SYNTAX;
return 0;
case '+': /* Positive value */
++digit;
break;
case '-': /* Negative value */
++digit;
sgn = -1;
break;
default:
if (!isdigit(*digit))
return WRDE_SYNTAX;
}
*result = 0;
for (; *digit && isdigit(*digit); ++digit)
*result = (*result * 10) + (*digit - '0');
*expr = digit;
*result *= sgn;
return 0;
}
static int eval_expr_multdiv(char **expr, long int *result)
{
long int arg;
/* Read a Value */
if (eval_expr_val(expr, result) != 0)
return WRDE_SYNTAX;
while (**expr) {
/* Skip white space */
for (; *expr && **expr && isspace(**expr); ++(*expr));
if (**expr == '*') {
++(*expr);
if (eval_expr_val(expr, &arg) != 0)
return WRDE_SYNTAX;
*result *= arg;
} else if (**expr == '/') {
++(*expr);
if (eval_expr_val(expr, &arg) != 0)
return WRDE_SYNTAX;
*result /= arg;
} else
break;
}
return 0;
}
static int eval_expr(char *expr, long int *result)
{
long int arg;
/* Read a Multdiv */
if (eval_expr_multdiv(&expr, result) != 0)
return WRDE_SYNTAX;
while (*expr) {
/* Skip white space */
for (; expr && *expr && isspace(*expr); ++expr);
if (*expr == '+') {
++expr;
if (eval_expr_multdiv(&expr, &arg) != 0)
return WRDE_SYNTAX;
*result += arg;
} else if (*expr == '-') {
++expr;
if (eval_expr_multdiv(&expr, &arg) != 0)
return WRDE_SYNTAX;
*result -= arg;
} else
break;
}
return 0;
}
static int
parse_arith(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags, int bracket)
{
/* We are poised just after "$((" or "$[" */
int error;
int paren_depth = 1;
size_t expr_length;
size_t expr_maxlen;
char *expr;
expr = w_newword(&expr_length, &expr_maxlen);
for (; words[*offset]; ++(*offset)) {
switch (words[*offset]) {
case '$':
error = parse_dollars(&expr, &expr_length, &expr_maxlen,
words, offset, flags, NULL, NULL, NULL,
1);
/* The ``1'' here is to tell parse_dollars not to
* split the fields.
*/
if (error) {
free(expr);
return error;
}
break;
case '`':
(*offset)++;
error = parse_backtick(&expr, &expr_length, &expr_maxlen,
words, offset, flags, NULL, NULL, NULL);
/* The first NULL here is to tell parse_backtick not to
* split the fields.
*/
if (error) {
free(expr);
return error;
}
break;
case '\\':
error = parse_qtd_backslash(&expr, &expr_length, &expr_maxlen,
words, offset);
if (error) {
free(expr);
return error;
}
/* I think that a backslash within an
* arithmetic expansion is bound to
* cause an error sooner or later anyway though.
*/
break;
case ')':
if (--paren_depth == 0) {
char result[21]; /* 21 = ceil(log10(2^64)) + 1 */
long int numresult = 0;
long long int convertme;
if (bracket || words[1 + *offset] != ')') {
free(expr);
return WRDE_SYNTAX;
}
++(*offset);
/* Go - evaluate. */
if (*expr && eval_expr(expr, &numresult) != 0) {
free(expr);
return WRDE_SYNTAX;
}
if (numresult < 0) {
convertme = -numresult;
*word = w_addchar(*word, word_length, max_length, '-');
if (!*word) {
free(expr);
return WRDE_NOSPACE;
}
} else
convertme = numresult;
result[20] = '\0';
*word = w_addstr(*word, word_length, max_length,
_itoa(convertme, &result[20]));
free(expr);
return *word ? 0 : WRDE_NOSPACE;
}
expr =
w_addchar(expr, &expr_length, &expr_maxlen,
words[*offset]);
if (expr == NULL)
return WRDE_NOSPACE;
break;
case ']':
if (bracket && paren_depth == 1) {
char result[21]; /* 21 = ceil(log10(2^64)) + 1 */
long int numresult = 0;
/* Go - evaluate. */
if (*expr && eval_expr(expr, &numresult) != 0) {
free(expr);
return WRDE_SYNTAX;
}
result[20] = '\0';
*word = w_addstr(*word, word_length, max_length,
_itoa(numresult, &result[20]));
free(expr);
return *word ? 0 : WRDE_NOSPACE;
}
free(expr);
return WRDE_SYNTAX;
case '\n':
case ';':
case '{':
case '}':
free(expr);
return WRDE_BADCHAR;
case '(':
++paren_depth;
default:
expr =
w_addchar(expr, &expr_length, &expr_maxlen,
words[*offset]);
if (expr == NULL)
return WRDE_NOSPACE;
}
}
/* Premature end */
free(expr);
return WRDE_SYNTAX;
}
/* Function called by child process in exec_comm() */
static void
exec_comm_child(char *comm, int *fildes, int showerr, int noexec)
{
const char *args[4] = { _PATH_BSHELL, "-c", comm, NULL };
/* Execute the command, or just check syntax? */
if (noexec)
args[1] = "-nc";
/* Redirect output. */
dup2(fildes[1], 1);
close(fildes[1]);
/* Redirect stderr to /dev/null if we have to. */
if (showerr == 0) {
int fd;
close(2);
fd = open(_PATH_DEVNULL, O_WRONLY);
if (fd >= 0 && fd != 2) {
dup2(fd, 2);
close(fd);
}
}
/* Make sure the subshell doesn't field-split on our behalf. */
unsetenv("IFS");
close(fildes[0]);
execve(_PATH_BSHELL, (char *const *) args, __environ);
/* Bad. What now? */
abort();
}
/* Function to execute a command and retrieve the results */
/* pwordexp contains NULL if field-splitting is forbidden */
static int
exec_comm(char *comm, char **word, size_t * word_length,
size_t * max_length, int flags, wordexp_t * pwordexp,
const char *ifs, const char *ifs_white)
{
int fildes[2];
int bufsize = 128;
int buflen;
int i;
int status = 0;
size_t maxnewlines = 0;
char *buffer;
pid_t pid;
/* Don't fork() unless necessary */
if (!comm || !*comm)
return 0;
if (pipe(fildes))
/* Bad */
return WRDE_NOSPACE;
if ((pid = fork()) < 0) {
/* Bad */
close(fildes[0]);
close(fildes[1]);
return WRDE_NOSPACE;
}
if (pid == 0)
exec_comm_child(comm, fildes, (flags & WRDE_SHOWERR), 0);
/* Parent */
close(fildes[1]);
buffer = alloca(bufsize);
if (!pwordexp)
/* Quoted - no field splitting */
{
while (1) {
if ((buflen = read(fildes[0], buffer, bufsize)) < 1) {
if (waitpid(pid, &status, WNOHANG) == 0)
continue;
if ((buflen = read(fildes[0], buffer, bufsize)) < 1)
break;
}
maxnewlines += buflen;
*word = w_addmem(*word, word_length, max_length, buffer, buflen);
if (*word == NULL)
goto no_space;
}
} else
/* Not quoted - split fields */
{
int copying = 0;
/* 'copying' is:
* 0 when searching for first character in a field not IFS white space
* 1 when copying the text of a field
* 2 when searching for possible non-whitespace IFS
* 3 when searching for non-newline after copying field
*/
while (1) {
if ((buflen = read(fildes[0], buffer, bufsize)) < 1) {
if (waitpid(pid, &status, WNOHANG) == 0)
continue;
if ((buflen = read(fildes[0], buffer, bufsize)) < 1)
break;
}
for (i = 0; i < buflen; ++i) {
if (strchr(ifs, buffer[i]) != NULL) {
/* Current character is IFS */
if (strchr(ifs_white, buffer[i]) == NULL) {
/* Current character is IFS but not whitespace */
if (copying == 2) {
/* current character
* |
* V
* eg: text<space><comma><space>moretext
*
* So, strip whitespace IFS (like at the start)
*/
copying = 0;
continue;
}
copying = 0;
/* fall through and delimit field.. */
} else {
if (buffer[i] == '\n') {
/* Current character is (IFS) newline */
/* If copying a field, this is the end of it,
but maybe all that's left is trailing newlines.
So start searching for a non-newline. */
if (copying == 1)
copying = 3;
continue;
} else {
/* Current character is IFS white space, but
not a newline */
/* If not either copying a field or searching
for non-newline after a field, ignore it */
if (copying != 1 && copying != 3)
continue;
/* End of field (search for non-ws IFS afterwards) */
copying = 2;
}
}
/* First IFS white space (non-newline), or IFS non-whitespace.
* Delimit the field. Nulls are converted by w_addword. */
if (w_addword(pwordexp, *word) == WRDE_NOSPACE)
goto no_space;
*word = w_newword(word_length, max_length);
maxnewlines = 0;
/* fall back round the loop.. */
} else {
/* Not IFS character */
if (copying == 3) {
/* Nothing but (IFS) newlines since the last field,
so delimit it here before starting new word */
if (w_addword(pwordexp, *word) == WRDE_NOSPACE)
goto no_space;
*word = w_newword(word_length, max_length);
}
copying = 1;
if (buffer[i] == '\n') /* happens if newline not in IFS */
maxnewlines++;
else
maxnewlines = 0;
*word = w_addchar(*word, word_length, max_length,
buffer[i]);
if (*word == NULL)
goto no_space;
}
}
}
}
/* Chop off trailing newlines (required by POSIX.2) */
/* Ensure we don't go back further than the beginning of the
substitution (i.e. remove maxnewlines bytes at most) */
while (maxnewlines-- != 0 &&
*word_length > 0 && (*word)[*word_length - 1] == '\n') {
(*word)[--*word_length] = '\0';
/* If the last word was entirely newlines, turn it into a new word
* which can be ignored if there's nothing following it. */
if (*word_length == 0) {
free(*word);
*word = w_newword(word_length, max_length);
break;
}
}
close(fildes[0]);
/* Check for syntax error (re-execute but with "-n" flag) */
if (buflen < 1 && status != 0) {
if ((pid = fork()) < 0) {
/* Bad */
return WRDE_NOSPACE;
}
if (pid == 0) {
fildes[0] = fildes[1] = -1;
exec_comm_child(comm, fildes, 0, 1);
}
if (waitpid(pid, &status, 0) == pid && status != 0)
return WRDE_SYNTAX;
}
return 0;
no_space:
kill(pid, SIGKILL);
waitpid(pid, NULL, 0);
close(fildes[0]);
return WRDE_NOSPACE;
}
static int
parse_comm(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs, const char *ifs_white)
{
/* We are poised just after "$(" */
int paren_depth = 1;
int error = 0;
int quoted = 0; /* 1 for singly-quoted, 2 for doubly-quoted */
size_t comm_length;
size_t comm_maxlen;
char *comm = w_newword(&comm_length, &comm_maxlen);
for (; words[*offset]; ++(*offset)) {
switch (words[*offset]) {
case '\'':
if (quoted == 0)
quoted = 1;
else if (quoted == 1)
quoted = 0;
break;
case '"':
if (quoted == 0)
quoted = 2;
else if (quoted == 2)
quoted = 0;
break;
case ')':
if (!quoted && --paren_depth == 0) {
/* Go -- give script to the shell */
if (comm) {
error = exec_comm(comm, word, word_length, max_length,
flags, pwordexp, ifs, ifs_white);
free(comm);
}
return error;
}
/* This is just part of the script */
break;
case '(':
if (!quoted)
++paren_depth;
}
comm = w_addchar(comm, &comm_length, &comm_maxlen, words[*offset]);
if (comm == NULL)
return WRDE_NOSPACE;
}
/* Premature end */
if (comm)
free(comm);
return WRDE_SYNTAX;
}
static int
parse_backtick(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs,
const char *ifs_white)
{
/* We are poised just after "`" */
int error;
int squoting = 0;
size_t comm_length;
size_t comm_maxlen;
char *comm = w_newword(&comm_length, &comm_maxlen);
for (; words[*offset]; ++(*offset)) {
switch (words[*offset]) {
case '`':
/* Go -- give the script to the shell */
error = exec_comm(comm, word, word_length, max_length, flags,
pwordexp, ifs, ifs_white);
free(comm);
return error;
case '\\':
if (squoting) {
error = parse_qtd_backslash(&comm, &comm_length, &comm_maxlen,
words, offset);
if (error) {
free(comm);
return error;
}
break;
}
++(*offset);
error = parse_backslash(&comm, &comm_length, &comm_maxlen, words,
offset);
if (error) {
free(comm);
return error;
}
break;
case '\'':
squoting = 1 - squoting;
default:
comm = w_addchar(comm, &comm_length, &comm_maxlen,
words[*offset]);
if (comm == NULL)
return WRDE_NOSPACE;
}
}
/* Premature end */
free(comm);
return WRDE_SYNTAX;
}
static int
parse_param(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs, const char *ifs_white,
int quoted)
{
/* We are poised just after "$" */
enum action {
ACT_NONE,
ACT_RP_SHORT_LEFT = '#',
ACT_RP_LONG_LEFT = 'L',
ACT_RP_SHORT_RIGHT = '%',
ACT_RP_LONG_RIGHT = 'R',
ACT_NULL_ERROR = '?',
ACT_NULL_SUBST = '-',
ACT_NONNULL_SUBST = '+',
ACT_NULL_ASSIGN = '='
};
size_t env_length;
size_t env_maxlen;
size_t pat_length;
size_t pat_maxlen;
size_t start = *offset;
char *env;
char *pattern;
char *value = NULL;
enum action action = ACT_NONE;
int depth = 0;
int colon_seen = 0;
int seen_hash = 0;
int free_value = 0;
int pattern_is_quoted = 0; /* 1 for singly-quoted, 2 for doubly-quoted */
int error;
int special = 0;
char buffer[21];
int brace = words[*offset] == '{';
env = w_newword(&env_length, &env_maxlen);
pattern = w_newword(&pat_length, &pat_maxlen);
if (brace)
++ * offset;
/* First collect the parameter name. */
if (words[*offset] == '#') {
seen_hash = 1;
if (!brace)
goto envsubst;
++*offset;
}
if (isalpha(words[*offset]) || words[*offset] == '_') {
/* Normal parameter name. */
do {
env = w_addchar(env, &env_length, &env_maxlen, words[*offset]);
if (env == NULL)
goto no_space;
}
while (isalnum(words[++*offset]) || words[*offset] == '_');
} else if (isdigit(words[*offset])) {
/* Numeric parameter name. */
special = 1;
do {
env = w_addchar(env, &env_length, &env_maxlen, words[*offset]);
if (env == NULL)
goto no_space;
if (!brace)
goto envsubst;
}
while (isdigit(words[++*offset]));
} else if (strchr("*@$", words[*offset]) != NULL) {
/* Special parameter. */
special = 1;
env = w_addchar(env, &env_length, &env_maxlen, words[*offset]);
if (env == NULL)
goto no_space;
++*offset;
} else {
if (brace)
goto syntax;
}
if (brace) {
/* Check for special action to be applied to the value. */
switch (words[*offset]) {
case '}':
/* Evaluate. */
goto envsubst;
case '#':
action = ACT_RP_SHORT_LEFT;
if (words[1 + *offset] == '#') {
++*offset;
action = ACT_RP_LONG_LEFT;
}
break;
case '%':
action = ACT_RP_SHORT_RIGHT;
if (words[1 + *offset] == '%') {
++*offset;
action = ACT_RP_LONG_RIGHT;
}
break;
case ':':
if (strchr("-=?+", words[1 + *offset]) == NULL)
goto syntax;
colon_seen = 1;
action = words[++*offset];
break;
case '-':
case '=':
case '?':
case '+':
action = words[*offset];
break;
default:
goto syntax;
}
/* Now collect the pattern, but don't expand it yet. */
++*offset;
for (; words[*offset]; ++(*offset)) {
switch (words[*offset]) {
case '{':
if (!pattern_is_quoted)
++depth;
break;
case '}':
if (!pattern_is_quoted) {
if (depth == 0)
goto envsubst;
--depth;
}
break;
case '\\':
if (pattern_is_quoted)
/* Quoted; treat as normal character. */
break;
/* Otherwise, it's an escape: next character is literal. */
if (words[++*offset] == '\0')
goto syntax;
pattern = w_addchar(pattern, &pat_length, &pat_maxlen, '\\');
if (pattern == NULL)
goto no_space;
break;
case '\'':
if (pattern_is_quoted == 0)
pattern_is_quoted = 1;
else if (pattern_is_quoted == 1)
pattern_is_quoted = 0;
break;
case '"':
if (pattern_is_quoted == 0)
pattern_is_quoted = 2;
else if (pattern_is_quoted == 2)
pattern_is_quoted = 0;
break;
}
pattern = w_addchar(pattern, &pat_length, &pat_maxlen,
words[*offset]);
if (pattern == NULL)
goto no_space;
}
}
/* End of input string -- remember to reparse the character that we
* stopped at. */
--(*offset);
envsubst:
if (words[start] == '{' && words[*offset] != '}')
goto syntax;
if (env == NULL) {
if (seen_hash) {
/* $# expands to the number of positional parameters */
buffer[20] = '\0';
value = _itoa(__libc_argc - 1, &buffer[20]);
seen_hash = 0;
} else {
/* Just $ on its own */
*offset = start - 1;
*word = w_addchar(*word, word_length, max_length, '$');
return *word ? 0 : WRDE_NOSPACE;
}
}
/* Is it a numeric parameter? */
else if (isdigit(env[0])) {
int n = atoi(env);
if (n >= __libc_argc)
/* Substitute NULL. */
value = NULL;
else
/* Replace with appropriate positional parameter. */
value = __libc_argv[n];
}
/* Is it a special parameter? */
else if (special) {
/* Is it `$$'? */
if (*env == '$') {
buffer[20] = '\0';
value = _itoa(getpid(), &buffer[20]);
}
/* Is it `${#*}' or `${#@}'? */
else if ((*env == '*' || *env == '@') && seen_hash) {
buffer[20] = '\0';
value = _itoa(__libc_argc > 0 ? __libc_argc - 1 : 0,
&buffer[20]);
*word = w_addstr(*word, word_length, max_length, value);
free(env);
if (pattern)
free(pattern);
return *word ? 0 : WRDE_NOSPACE;
}
/* Is it `$*' or `$@' (unquoted) ? */
else if (*env == '*' || (*env == '@' && !quoted)) {
size_t plist_len = 0;
int p;
char *end;
/* Build up value parameter by parameter (copy them) */
for (p = 1; __libc_argv[p]; ++p)
plist_len += strlen(__libc_argv[p]) + 1; /* for space */
value = malloc(plist_len);
if (value == NULL)
goto no_space;
end = value;
*end = 0;
for (p = 1; __libc_argv[p]; ++p) {
if (p > 1)
*end++ = ' ';
end = stpcpy(end, __libc_argv[p]);
}
free_value = 1;
} else {
/* Must be a quoted `$@' */
assert(*env == '@' && quoted);
/* Each parameter is a separate word ("$@") */
if (__libc_argc == 2)
value = __libc_argv[1];
else if (__libc_argc > 2) {
int p;
/* Append first parameter to current word. */
value = w_addstr(*word, word_length, max_length,
__libc_argv[1]);
if (value == NULL || w_addword(pwordexp, value))
goto no_space;
for (p = 2; __libc_argv[p + 1]; p++) {
char *newword = strdup(__libc_argv[p]);
if (newword == NULL || w_addword(pwordexp, newword))
goto no_space;
}
/* Start a new word with the last parameter. */
*word = w_newword(word_length, max_length);
value = __libc_argv[p];
} else {
free(env);
free(pattern);
return 0;
}
}
} else
value = getenv(env);
if (value == NULL && (flags & WRDE_UNDEF)) {
/* Variable not defined. */
error = WRDE_BADVAL;
goto do_error;
}
if (action != ACT_NONE) {
int expand_pattern = 0;
/* First, find out if we need to expand pattern (i.e. if we will
* use it). */
switch (action) {
case ACT_RP_SHORT_LEFT:
case ACT_RP_LONG_LEFT:
case ACT_RP_SHORT_RIGHT:
case ACT_RP_LONG_RIGHT:
/* Always expand for these. */
expand_pattern = 1;
break;
case ACT_NULL_ERROR:
case ACT_NULL_SUBST:
case ACT_NULL_ASSIGN:
if (!value || (!*value && colon_seen))
/* If param is unset, or set but null and a colon has been seen,
the expansion of the pattern will be needed. */
expand_pattern = 1;
break;
case ACT_NONNULL_SUBST:
/* Expansion of word will be needed if parameter is set and not null,
or set null but no colon has been seen. */
if (value && (*value || !colon_seen))
expand_pattern = 1;
break;
default:
assert(!"Unrecognised action!");
}
if (expand_pattern) {
/* We need to perform tilde expansion, parameter expansion,
command substitution, and arithmetic expansion. We also
have to be a bit careful with wildcard characters, as
pattern might be given to fnmatch soon. To do this, we
convert quotes to escapes. */
char *expanded;
size_t exp_len;
size_t exp_maxl;
char *p;
int quoted = 0; /* 1: single quotes; 2: double */
expanded = w_newword(&exp_len, &exp_maxl);
for (p = pattern; p && *p; p++) {
size_t offset;
switch (*p) {
case '"':
if (quoted == 2)
quoted = 0;
else if (quoted == 0)
quoted = 2;
else
break;
continue;
case '\'':
if (quoted == 1)
quoted = 0;
else if (quoted == 0)
quoted = 1;
else
break;
continue;
case '*':
case '?':
if (quoted) {
/* Convert quoted wildchar to escaped wildchar. */
expanded = w_addchar(expanded, &exp_len,
&exp_maxl, '\\');
if (expanded == NULL)
goto no_space;
}
break;
case '$':
offset = 0;
error = parse_dollars(&expanded, &exp_len, &exp_maxl, p,
&offset, flags, NULL, NULL, NULL, 1);
if (error) {
if (free_value)
free(value);
if (expanded)
free(expanded);
goto do_error;
}
p += offset;
continue;
case '~':
if (quoted || exp_len)
break;
offset = 0;
error = parse_tilde(&expanded, &exp_len, &exp_maxl, p,
&offset, 0);
if (error) {
if (free_value)
free(value);
if (expanded)
free(expanded);
goto do_error;
}
p += offset;
continue;
case '\\':
expanded = w_addchar(expanded, &exp_len, &exp_maxl, '\\');
++p;
assert(*p); /* checked when extracted initially */
if (expanded == NULL)
goto no_space;
}
expanded = w_addchar(expanded, &exp_len, &exp_maxl, *p);
if (expanded == NULL)
goto no_space;
}
if (pattern)
free(pattern);
pattern = expanded;
}
switch (action) {
case ACT_RP_SHORT_LEFT:
case ACT_RP_LONG_LEFT:
case ACT_RP_SHORT_RIGHT:
case ACT_RP_LONG_RIGHT:
{
char *p;
char c;
char *end;
if (value == NULL || pattern == NULL || *pattern == '\0')
break;
end = value + strlen(value);
switch (action) {
case ACT_RP_SHORT_LEFT:
for (p = value; p <= end; ++p) {
c = *p;
*p = '\0';
if (fnmatch(pattern, value, 0) != FNM_NOMATCH) {
*p = c;
if (free_value) {
char *newval = strdup(p);
if (newval == NULL) {
free(value);
goto no_space;
}
free(value);
value = newval;
} else
value = p;
break;
}
*p = c;
}
break;
case ACT_RP_LONG_LEFT:
for (p = end; p >= value; --p) {
c = *p;
*p = '\0';
if (fnmatch(pattern, value, 0) != FNM_NOMATCH) {
*p = c;
if (free_value) {
char *newval = strdup(p);
if (newval == NULL) {
free(value);
goto no_space;
}
free(value);
value = newval;
} else
value = p;
break;
}
*p = c;
}
break;
case ACT_RP_SHORT_RIGHT:
for (p = end; p >= value; --p) {
if (fnmatch(pattern, p, 0) != FNM_NOMATCH) {
char *newval;
newval = malloc(p - value + 1);
if (newval == NULL) {
if (free_value)
free(value);
goto no_space;
}
*(char *) mempcpy(newval, value, p - value) = '\0';
if (free_value)
free(value);
value = newval;
free_value = 1;
break;
}
}
break;
case ACT_RP_LONG_RIGHT:
for (p = value; p <= end; ++p) {
if (fnmatch(pattern, p, 0) != FNM_NOMATCH) {
char *newval;
newval = malloc(p - value + 1);
if (newval == NULL) {
if (free_value)
free(value);
goto no_space;
}
*(char *) mempcpy(newval, value, p - value) = '\0';
if (free_value)
free(value);
value = newval;
free_value = 1;
break;
}
}
break;
default:
break;
}
break;
}
case ACT_NULL_ERROR:
if (value && *value)
/* Substitute parameter */
break;
error = 0;
if (!colon_seen && value)
/* Substitute NULL */
;
else if (*pattern)
fprintf(stderr, "%s: %s\n", env, pattern);
else {
fprintf(stderr, "%s: parameter null or not set\n", env);
error = WRDE_BADVAL;
}
if (free_value)
free(value);
goto do_error;
case ACT_NULL_SUBST:
if (value && *value)
/* Substitute parameter */
break;
if (free_value && value)
free(value);
if (!colon_seen && value)
/* Substitute NULL */
goto success;
value = pattern ? strdup(pattern) : pattern;
free_value = 1;
if (pattern && !value)
goto no_space;
break;
case ACT_NONNULL_SUBST:
if (value && (*value || !colon_seen)) {
if (free_value && value)
free(value);
value = pattern ? strdup(pattern) : pattern;
free_value = 1;
if (pattern && !value)
goto no_space;
break;
}
/* Substitute NULL */
if (free_value)
free(value);
goto success;
case ACT_NULL_ASSIGN:
if (value && *value)
/* Substitute parameter */
break;
if (!colon_seen && value) {
/* Substitute NULL */
if (free_value)
free(value);
goto success;
}
if (free_value && value)
free(value);
value = pattern ? strdup(pattern) : pattern;
free_value = 1;
if (pattern && !value)
goto no_space;
setenv(env, value, 1);
break;
default:
assert(!"Unrecognised action!");
}
}
free(env);
env = NULL;
free(pattern);
pattern = NULL;
if (seen_hash) {
char param_length[21];
param_length[20] = '\0';
*word = w_addstr(*word, word_length, max_length,
_itoa(value ? strlen(value) : 0,
¶m_length[20]));
if (free_value) {
assert(value != NULL);
free(value);
}
return *word ? 0 : WRDE_NOSPACE;
}
if (value == NULL)
return 0;
if (quoted || !pwordexp) {
/* Quoted - no field split */
*word = w_addstr(*word, word_length, max_length, value);
if (free_value)
free(value);
return *word ? 0 : WRDE_NOSPACE;
} else {
/* Need to field-split */
char *value_copy = strdup(value); /* Don't modify value */
char *field_begin = value_copy;
int seen_nonws_ifs = 0;
if (free_value)
free(value);
if (value_copy == NULL)
goto no_space;
do {
char *field_end = field_begin;
char *next_field;
/* If this isn't the first field, start a new word */
if (field_begin != value_copy) {
if (w_addword(pwordexp, *word) == WRDE_NOSPACE) {
free(value_copy);
goto no_space;
}
*word = w_newword(word_length, max_length);
}
/* Skip IFS whitespace before the field */
field_begin += strspn(field_begin, ifs_white);
if (!seen_nonws_ifs && *field_begin == 0)
/* Nothing but whitespace */
break;
/* Search for the end of the field */
field_end = field_begin + strcspn(field_begin, ifs);
/* Set up pointer to the character after end of field and
skip whitespace IFS after it. */
next_field = field_end + strspn(field_end, ifs_white);
/* Skip at most one non-whitespace IFS character after the field */
seen_nonws_ifs = 0;
if (*next_field && strchr(ifs, *next_field)) {
seen_nonws_ifs = 1;
next_field++;
}
/* Null-terminate it */
*field_end = 0;
/* Tag a copy onto the current word */
*word = w_addstr(*word, word_length, max_length, field_begin);
if (*word == NULL && *field_begin != '\0') {
free(value_copy);
goto no_space;
}
field_begin = next_field;
}
while (seen_nonws_ifs || *field_begin);
free(value_copy);
}
return 0;
success:
error = 0;
goto do_error;
no_space:
error = WRDE_NOSPACE;
goto do_error;
syntax:
error = WRDE_SYNTAX;
do_error:
if (env)
free(env);
if (pattern)
free(pattern);
return error;
}
#else
static inline int
parse_backtick(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs,
const char *ifs_white)
{
return 0;
}
#endif
static int
parse_dollars(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs, const char *ifs_white,
int quoted)
{
/* We are poised _at_ "$" */
switch (words[1 + *offset]) {
case '"':
case '\'':
case 0:
*word = w_addchar(*word, word_length, max_length, '$');
return *word ? 0 : WRDE_NOSPACE;
#ifdef __WORDEXP_FULL
case '(':
if (words[2 + *offset] == '(') {
/* Differentiate between $((1+3)) and $((echo);(ls)) */
int i = 3 + *offset;
int depth = 0;
while (words[i] && !(depth == 0 && words[i] == ')')) {
if (words[i] == '(')
++depth;
else if (words[i] == ')')
--depth;
++i;
}
if (words[i] == ')' && words[i + 1] == ')') {
(*offset) += 3;
/* Call parse_arith -- 0 is for "no brackets" */
return parse_arith(word, word_length, max_length, words,
offset, flags, 0);
}
}
if (flags & WRDE_NOCMD)
return WRDE_CMDSUB;
(*offset) += 2;
return parse_comm(word, word_length, max_length, words, offset,
flags, quoted ? NULL : pwordexp, ifs, ifs_white);
case '[':
(*offset) += 2;
/* Call parse_arith -- 1 is for "brackets" */
return parse_arith(word, word_length, max_length, words, offset,
flags, 1);
case '{':
default:
++(*offset); /* parse_param needs to know if "{" is there */
return parse_param(word, word_length, max_length, words, offset,
flags, pwordexp, ifs, ifs_white, quoted);
#else
default:
++(*offset); /* parse_param needs to know if "{" is there */
return 0;
#endif
}
}
static int
parse_dquote(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs, const char *ifs_white)
{
/* We are poised just after a double-quote */
int error;
for (; words[*offset]; ++(*offset)) {
switch (words[*offset]) {
case '"':
return 0;
case '$':
error = parse_dollars(word, word_length, max_length, words, offset,
flags, pwordexp, ifs, ifs_white, 1);
/* The ``1'' here is to tell parse_dollars not to
* split the fields. It may need to, however ("$@").
*/
if (error)
return error;
break;
case '`':
if (flags & WRDE_NOCMD)
return WRDE_CMDSUB;
++(*offset);
error = parse_backtick(word, word_length, max_length, words,
offset, flags, NULL, NULL, NULL);
/* The first NULL here is to tell parse_backtick not to
* split the fields.
*/
if (error)
return error;
break;
case '\\':
error = parse_qtd_backslash(word, word_length, max_length, words,
offset);
if (error)
return error;
break;
default:
*word = w_addchar(*word, word_length, max_length, words[*offset]);
if (*word == NULL)
return WRDE_NOSPACE;
}
}
/* Unterminated string */
return WRDE_SYNTAX;
}
/*
* wordfree() is to be called after pwordexp is finished with.
*/
void wordfree(wordexp_t * pwordexp)
{
/* wordexp can set pwordexp to NULL */
if (pwordexp && pwordexp->we_wordv) {
char **wordv = pwordexp->we_wordv;
for (wordv += pwordexp->we_offs; *wordv; ++wordv)
free(*wordv);
free(pwordexp->we_wordv);
pwordexp->we_wordv = NULL;
}
}
/*
* wordexp()
*/
int wordexp(const char *words, wordexp_t * we, int flags)
{
size_t words_offset;
size_t word_length;
size_t max_length;
char *word = w_newword(&word_length, &max_length);
int error;
char *ifs;
char ifs_white[4];
wordexp_t old_word = *we;
if (flags & WRDE_REUSE) {
/* Minimal implementation of WRDE_REUSE for now */
wordfree(we);
old_word.we_wordv = NULL;
}
if ((flags & WRDE_APPEND) == 0) {
we->we_wordc = 0;
if (flags & WRDE_DOOFFS) {
we->we_wordv = calloc(1 + we->we_offs, sizeof(char *));
if (we->we_wordv == NULL) {
error = WRDE_NOSPACE;
goto do_error;
}
} else {
we->we_wordv = calloc(1, sizeof(char *));
if (we->we_wordv == NULL) {
error = WRDE_NOSPACE;
goto do_error;
}
we->we_offs = 0;
}
}
/* Find out what the field separators are.
* There are two types: whitespace and non-whitespace.
*/
ifs = getenv("IFS");
if (!ifs)
/* IFS unset - use <space><tab><newline>. */
ifs = strcpy(ifs_white, " \t\n");
else {
char *ifsch = ifs;
char *whch = ifs_white;
/* Start off with no whitespace IFS characters */
ifs_white[0] = '\0';
while (*ifsch != '\0') {
if ((*ifsch == ' ') || (*ifsch == '\t') || (*ifsch == '\n')) {
/* Whitespace IFS. See first whether it is already in our
collection. */
char *runp = ifs_white;
while (runp < whch && *runp != '\0' && *runp != *ifsch)
++runp;
if (runp == whch)
*whch++ = *ifsch;
}
++ifsch;
}
*whch = '\0';
}
for (words_offset = 0; words[words_offset]; ++words_offset)
switch (words[words_offset]) {
case '\\':
error = parse_backslash(&word, &word_length, &max_length, words,
&words_offset);
if (error)
goto do_error;
break;
case '$':
error = parse_dollars(&word, &word_length, &max_length, words,
&words_offset, flags, we, ifs, ifs_white,
0);
if (error)
goto do_error;
break;
case '`':
if (flags & WRDE_NOCMD) {
error = WRDE_CMDSUB;
goto do_error;
}
++words_offset;
error = parse_backtick(&word, &word_length, &max_length, words,
&words_offset, flags, we, ifs,
ifs_white);
if (error)
goto do_error;
break;
case '"':
++words_offset;
error = parse_dquote(&word, &word_length, &max_length, words,
&words_offset, flags, we, ifs, ifs_white);
if (error)
goto do_error;
if (!word_length) {
error = w_addword(we, NULL);
if (error)
return error;
}
break;
case '\'':
++words_offset;
error = parse_squote(&word, &word_length, &max_length, words,
&words_offset);
if (error)
goto do_error;
if (!word_length) {
error = w_addword(we, NULL);
if (error)
return error;
}
break;
case '~':
error = parse_tilde(&word, &word_length, &max_length, words,
&words_offset, we->we_wordc);
if (error)
goto do_error;
break;
case '*':
case '[':
case '?':
error = parse_glob(&word, &word_length, &max_length, words,
&words_offset, flags, we, ifs, ifs_white);
if (error)
goto do_error;
break;
default:
/* Is it a word separator? */
if (strchr(" \t", words[words_offset]) == NULL) {
char ch = words[words_offset];
/* Not a word separator -- but is it a valid word char? */
if (strchr("\n|&;<>(){}", ch)) {
/* Fail */
error = WRDE_BADCHAR;
goto do_error;
}
/* "Ordinary" character -- add it to word */
word = w_addchar(word, &word_length, &max_length, ch);
if (word == NULL) {
error = WRDE_NOSPACE;
goto do_error;
}
break;
}
/* If a word has been delimited, add it to the list. */
if (word != NULL) {
error = w_addword(we, word);
if (error)
goto do_error;
}
word = w_newword(&word_length, &max_length);
}
/* End of string */
/* There was a word separator at the end */
if (word == NULL) /* i.e. w_newword */
return 0;
/* There was no field separator at the end */
return w_addword(we, word);
do_error:
/* Error:
* free memory used (unless error is WRDE_NOSPACE), and
* set we members back to what they were.
*/
if (word != NULL)
free(word);
if (error == WRDE_NOSPACE)
return WRDE_NOSPACE;
if ((flags & WRDE_APPEND) == 0)
wordfree(we);
*we = old_word;
return error;
}
|
the_stack_data/75138778.c | #include <stdio.h>
/*三个学生，四门功课，求平均成绩；打印第n个学生的成绩*/
void average(int *,int);
void show_n(int (*p)[4], int n);
int main(){
int arr[3][4] = {
{99,98,97,96},
{96,97,98,99},
{98,96,97,99}
};
average(*arr,12);
show_n(arr,2);
return 0;
}
void average(int *p,int n){
int i;
float sum=0.0;
for(i=0;i<n;i++){
sum += *(p+i);
}
printf("the average is:%f\n",sum/n);
}
void show_n(int (*p)[4], int n){
int i =0;
printf("the %d student's scores is :",n);
for(i=0;i<4;i++){
printf("%d\t",*(*(p+n)+i));
}
printf("\n");
}
|
the_stack_data/28261485.c | #include <stdio.h>
int BinarySearchIterative(int array[], int size, int element_to_find);
int main(){
/* Creating an array of size 10 & variable with justified name */
int array[10] = {15, 18, 42, 69, 78, 47, 78, 45, 96, 10};
int element_to_find, element_location_in_array, element_position;
/* Printing the array we hardcoded */
printf("\nThe array which i hardcoded is :- [ ");
for(int i=0; i<10; i++)
{
printf("%d", array[i]);
if(i == 9)
{
printf("");
}
else
{
printf(", ");
}
}
printf(" ]\n\n");
/* Taking input of the element to search and finding it */
printf("Enter element to search from above : ");
scanf("%d", &element_to_find);
/* Finding the element using iterative method */
element_position = BinarySearchIterative(array, 10, element_to_find);
if (element_position == -1)
{
printf("\nNOO We didn't found the element %d\n\n", element_to_find);
}
else
{
printf("\nYASS We found the element %d in index %d\n\n", element_to_find, element_position + 1);
}
return 0;
}
int BinarySearchIterative(int array[], int size, int element_to_find) {
int start = 0;
int end = size-1;
while(start<=end) {
int mid = (start+end)/2;
if( array[mid] == element_to_find) {
return mid;
} else if( element_to_find < array[mid] ) {
end = mid-1;
} else {
start = mid+1;
}
}
return -1;
}
|
the_stack_data/200142197.c | // RUN: %clam -O0 --crab-inter --crab-dom=int --crab-track=arr --crab-check=assert --crab-sanity-checks "%s" 2>&1 | OutputCheck %s
// CHECK: ^1 Number of total safe checks$
// CHECK: ^0 Number of total error checks$
// CHECK: ^0 Number of total warning checks$
extern void __CRAB_assert(int);
int rec1 (int x);
int rec2 (int y);
int foo (int x) {
int y = x +1;
return y + 2;
}
int bar (int a) {
int x = a;
int w = 5;
return foo (x);
}
int rec1 (int x) {
if (x == 0) return 0;
else return rec2 (x-1);
}
int rec2 (int x) {
return rec1 (x);
}
int main (){
int x = 3;
int y = bar (x);
int z = rec1 (y);
int w= foo (y);
__CRAB_assert (w == 9);
return z + w;
}
|
the_stack_data/929261.c | // RUN: %clang %s -### \
// RUN: -fuse-ld=/usr/local/bin/or1k-linux-ld 2>&1 \
// RUN: | FileCheck %s --check-prefix=CHECK-ABSOLUTE-LD
// CHECK-ABSOLUTE-LD: /usr/local/bin/or1k-linux-ld
// RUN: %clang %s -### \
// RUN: -target x86_64-unknown-freebsd 2>&1 \
// RUN: | FileCheck %s --check-prefix=CHECK-FREEBSD-LD
// CHECK-FREEBSD-LD: ld
// RUN: %clang %s -### -fuse-ld=bfd \
// RUN: --sysroot=%S/Inputs/basic_freebsd_tree \
// RUN: -target x86_64-unknown-freebsd \
// RUN: -B%S/Inputs/basic_freebsd_tree/usr/bin 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-FREEBSD-BFD
// CHECK-FREEBSD-BFD: Inputs/basic_freebsd_tree/usr/bin{{/|\\+}}ld.bfd
// RUN: %clang %s -### -fuse-ld=gold \
// RUN: --sysroot=%S/Inputs/basic_freebsd_tree \
// RUN: -target x86_64-unknown-freebsd \
// RUN: -B%S/Inputs/basic_freebsd_tree/usr/bin 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-FREEBSD-GOLD
// CHECK-FREEBSD-GOLD: Inputs/basic_freebsd_tree/usr/bin{{/|\\+}}ld.gold
// RUN: %clang %s -### -fuse-ld=plib \
// RUN: --sysroot=%S/Inputs/basic_freebsd_tree \
// RUN: -target x86_64-unknown-freebsd \
// RUN: -B%S/Inputs/basic_freebsd_tree/usr/bin 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-FREEBSD-PLIB
// CHECK-FREEBSD-PLIB: error: invalid linker name
// RUN: %clang %s -### -fuse-ld=ld \
// RUN: -target arm-linux-androideabi \
// RUN: -B%S/Inputs/basic_android_tree/bin 2>&1 \
// RUN: | FileCheck %s --check-prefix=CHECK-ANDROID-ARM-LD
// CHECK-ANDROID-ARM-LD: Inputs/basic_android_tree/bin{{/|\\+}}arm-linux-androideabi-ld
// RUN: %clang %s -### -fuse-ld=bfd \
// RUN: -target arm-linux-androideabi \
// RUN: -B%S/Inputs/basic_android_tree/bin 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-ANDROID-ARM-BFD
// CHECK-ANDROID-ARM-BFD: Inputs/basic_android_tree/bin{{/|\\+}}arm-linux-androideabi-ld.bfd
// RUN: %clang %s -### -fuse-ld=gold \
// RUN: -target arm-linux-androideabi \
// RUN: -B%S/Inputs/basic_android_tree/bin 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-ANDROID-ARM-GOLD
// CHECK-ANDROID-ARM-GOLD: Inputs/basic_android_tree/bin{{/|\\+}}arm-linux-androideabi-ld.gold
// RUN: %clang %s -### -fuse-ld=ld \
// RUN: -target arm-linux-androideabi \
// RUN: -gcc-toolchain %S/Inputs/basic_android_tree 2>&1 \
// RUN: | FileCheck %s --check-prefix=CHECK-ANDROID-ARM-LD-TC
// CHECK-ANDROID-ARM-LD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.4.3/../../../../arm-linux-androideabi/bin{{/|\\+}}ld
// RUN: %clang %s -### -fuse-ld=bfd \
// RUN: -target arm-linux-androideabi \
// RUN: -gcc-toolchain %S/Inputs/basic_android_tree 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-ANDROID-ARM-BFD-TC
// CHECK-ANDROID-ARM-BFD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.4.3/../../../../arm-linux-androideabi/bin{{/|\\+}}ld.bfd
// RUN: %clang %s -### -fuse-ld=gold \
// RUN: -target arm-linux-androideabi \
// RUN: -gcc-toolchain %S/Inputs/basic_android_tree 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-ANDROID-ARM-GOLD-TC
// CHECK-ANDROID-ARM-GOLD-TC: Inputs/basic_android_tree/lib/gcc/arm-linux-androideabi/4.4.3/../../../../arm-linux-androideabi/bin{{/|\\+}}ld.gold
// RUN: %clang %s -### -fuse-ld=link \
// RUN: -target i686-unknown-windows-msvc 2>&1 \
// RUN: | FileCheck %s --check-prefix CHECK-WINDOWS-MSVC-LINK
// CHECK-WINDOWS-MSVC-LINK: "{{.*}}link.exe"
// CHECK-WINDOWS-MSVC-LINK-SAME: "-out:{{.*}}"
// RUN: %clang %s -### -fuse-ld=lld \
// RUN: -target i686-unknown-windows-msvc 2>&1 \
// RUN: | FileCheck %s --check-prefix CHECK-WINDOWS-MSVC-LLD
// CHECK-WINDOWS-MSVC-LLD: "{{.*}}lld-link"
// CHECK-WINDOWS-MSVC-LLD-SAME: "-out:{{.*}}"
// RUN: %clang %s -### -fuse-ld=lld-link \
// RUN: -target i686-unknown-windows-msvc 2>&1 \
// RUN: | FileCheck %s --check-prefix CHECK-WINDOWS-MSVC-LLD-LINK
// CHECK-WINDOWS-MSVC-LLD-LINK: "{{.*}}lld-link"
// CHECK-WINDOWS-MSVC-LLD-LINK-SAME: "-out:{{.*}}"
// RUN: %clang %s -### -fuse-ld=bfd \
// RUN: -target i686-unknown-windows-msvc \
// RUN: -B %S/Inputs/Windows/usr/bin 2>&1 \
// RUN: | FileCheck %s --check-prefix CHECK-WINDOWS-MSVC-BFD
// CHECK-WINDOWS-MSVC-BFD: "{{.*}}ld.bfd"
// CHECK-WINDOWS-MSVC-BFD-SAME: "-o"
|
the_stack_data/715178.c | /* { dg-do link } */
/* { dg-options "-O -ffast-math" } */
extern void link_error(void);
void test(double x, int n)
{
if (__builtin_powi(x,-1.0) != 1.0/x)
link_error ();
if (__builtin_powi(x,0.0) != 1.0)
link_error ();
if (__builtin_powi(x,1.0) != x)
link_error ();
if (__builtin_powi(1.0,n) != 1.0)
link_error ();
}
int main()
{
test(7.3, 2);
return 0;
}
|
the_stack_data/1225478.c | /** \file 4dstencil.c
* Copyright (c) 2014, Lawrence Livermore National Security, LLC.
* Produced at the Lawrence Livermore National Laboratory.
*
* Written by:
* Nikhil Jain <[email protected]>
* Abhinav Bhatele <[email protected]>
*
* LLNL-CODE-678959. All rights reserved.
*
* This file is part of Graphator. For details, see:
* https://github.com/LLNL/graphator
* Please also read the LICENSE file for our notice and the LGPL.
*/
#include <stdio.h>
#include <stdlib.h>
/* We want to wrap entries around, and because mod operator % sometimes
* misbehaves on negative values. -1 maps to the highest value. */
#define wrap_x(a) (((a)+num_blocks_x)%num_blocks_x)
#define wrap_y(a) (((a)+num_blocks_y)%num_blocks_y)
#define wrap_z(a) (((a)+num_blocks_z)%num_blocks_z)
#define wrap_t(a) (((a)+num_blocks_t)%num_blocks_t)
#define calc_pe(a,b,c,d) ((a)+(b)*num_blocks_x+(c)*num_blocks_x*num_blocks_y \
+(d)*num_blocks_x*num_blocks_y*num_blocks_z)
int main(int argc, char **argv) {
int my_rank;
if (argc != 6) {
printf("%s [num_blocks_x] [num_blocks_y] [num_blocks_z] [num_blocks_t] [msg_size]\n", argv[0]);
exit(EXIT_FAILURE);
}
int num_blocks_x = atoi(argv[1]);
int num_blocks_y = atoi(argv[2]);
int num_blocks_z = atoi(argv[3]);
int num_blocks_t = atoi(argv[4]);
int msg_size = atoi(argv[5]);
#if DEBUG
printf("4D Stencil on %d processors with aspect ratio (%d, %d, %d, %d)\n", (num_blocks_x*num_blocks_y*num_blocks_z*num_blocks_t), num_blocks_x, num_blocks_y, num_blocks_z, num_blocks_t);
#endif
for(my_rank = 0; my_rank < num_blocks_x*num_blocks_y*num_blocks_z*num_blocks_t; my_rank++) {
int my_x_coord = my_rank % num_blocks_x;
int my_y_coord = (my_rank % (num_blocks_x * num_blocks_y)) / num_blocks_x;
int my_z_coord = (my_rank % (num_blocks_x * num_blocks_y * num_blocks_z)) / (num_blocks_x * num_blocks_y);
int my_t_coord = my_rank / (num_blocks_x * num_blocks_y * num_blocks_z);
printf("%d %d %zd\n", my_rank, calc_pe(wrap_x(my_x_coord-1), my_y_coord, my_z_coord, my_t_coord), msg_size);
printf("%d %d %zd\n", my_rank, calc_pe(wrap_x(my_x_coord+1), my_y_coord, my_z_coord, my_t_coord), msg_size);
printf("%d %d %zd\n", my_rank, calc_pe(my_x_coord, wrap_y(my_y_coord-1), my_z_coord, my_t_coord), msg_size);
printf("%d %d %zd\n", my_rank, calc_pe(my_x_coord, wrap_y(my_y_coord+1), my_z_coord, my_t_coord), msg_size);
printf("%d %d %zd\n", my_rank, calc_pe(my_x_coord, my_y_coord, wrap_z(my_z_coord-1), my_t_coord), msg_size);
printf("%d %d %zd\n", my_rank, calc_pe(my_x_coord, my_y_coord, wrap_z(my_z_coord+1), my_t_coord), msg_size);
printf("%d %d %zd\n", my_rank, calc_pe(my_x_coord, my_y_coord, my_z_coord, wrap_t(my_t_coord-1)), msg_size);
printf("%d %d %zd\n", my_rank, calc_pe(my_x_coord, my_y_coord, my_z_coord, wrap_t(my_t_coord+1)), msg_size);
} /* end of for loop */
exit(EXIT_FAILURE);
} /* end function main */
|
the_stack_data/176705945.c | //
// main.c
// LearnC
//
// Created by 王镜淇 on 2020/10/26.
// Copyright © 2020 王镜淇. All rights reserved.
//
#include <stdio.h>
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, World!\n");
return 0;
}
|
the_stack_data/113606.c | //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ____ ___ __ _
// / __// o |,'_/ .' \
// / _/ / _,'/ /_n / o / _ __ _ ___ _ _ __
// /_/ /_/ |__,'/_n_/ / \,' /.' \ ,' _/,' \ / |/ /
// / \,' // o /_\ `./ o // || /
// /_/ /_//_n_//___,'|_,'/_/|_/
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Author : Wesley Taylor-Rendal (WTR)
// Design history : Review git logs.
// Description : Using Multidimensional Arrays and Functions
// Concepts : Multidimensional array must have column specified but not
// : row.
// : Indexing element within can be used for funct that doens't
// : take array for example sqrt(matrix[i][j])
// : The functional prototype declaration is NEEDed in this
// : example because of order. This enables writing out the
// : skeleton on the code before even looking at the
// : funtion.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <stdio.h>
int main(void)
{
void scalarMultiply (int matrix[3][5], int scalar);
void displayMatrix (int matrix[3][5]);
int sampleMatrix[3][5] =
{
{7, 16, 55, 13, 12},
{12, 10, 52, 0, 7},
{-2, 1, 2, 4, 9}
};
printf("Original matrix\n");
displayMatrix(sampleMatrix);
printf("\n");
printf("Multiplied by 2 : \n");
scalarMultiply(sampleMatrix, 2);
displayMatrix(sampleMatrix);
printf("Then multiplied by -1 : \n");
scalarMultiply(sampleMatrix, -1); // yes i changed the order, sue me
displayMatrix(sampleMatrix);
}
// Funct to mult
void scalarMultiply (int matrix[3][5], int scalar)
{
int row, column;
for (row=0; row<3; ++row)
for (column=0; column<5; ++column)
matrix[row][column] *= scalar;
}
void displayMatrix (int matrix[3][5])
{
int row, column;
for (row=0; row<3; ++row)
{
for (column=0; column<5; ++column)
printf("%5i", matrix[row][column]);
printf("\n");
}
}
|
the_stack_data/134140.c |
#include <stdio.h>
#include <string.h>
/*---------------------------------------------------------------------------*/
int getline_vicar (s, linelength, infile, eof)
char *s;
int linelength;
FILE *infile;
int *eof;
{
int c, i = 0;
memset (s,'\0',linelength);
while (i < linelength && (c=getc(infile)) != EOF && c != '\n')
s[i++] = c;
if (c == '\n')
s[i++] = c;
*eof = (c == EOF) ? 1 : 0;
return i;
}
|
the_stack_data/12636983.c | #include <stdio.h>
#include <stdlib.h>
int main()
{
unsigned int i, size;
int *a = NULL, *b = NULL, *sum = NULL;
printf("Enter size of array: ");
scanf("%u", &size);
a = (int *)calloc(size, sizeof(int));
b = (int *)calloc(size, sizeof(int));
sum = (int *)calloc(size, sizeof(int));
printf("\nEnter elements for 1st array:\n");
for (i = 0; i < size; i++)
{
printf("Enter element %u: ", i + 1);
scanf("%d", &a[i]);
sum[i] = a[i];
}
printf("\nEnter elements for 2nd array:\n");
for (i = 0; i < size; i++)
{
printf("Enter element %u: ", i + 1);
scanf("%d", &b[i]);
sum[i] += b[i];
}
printf("\nSum of the elements are:\n");
for (i = 0; i < size; i++)
printf("%d + %d = %d\n", a[i], b[i], sum[i]);
free(a);
free(b);
free(sum);
return 0;
}
|
the_stack_data/218893869.c | #include "stdio.h"
int main()
{
int a = 10;
while(a-- > 0){
printf("%d\n", a);
}
return 0;
} |
the_stack_data/159515263.c | /*
*
* Copyright (c) 1997
* Moscow Center for SPARC Technology
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#ifndef _STLP_DEBUG_C
#define _STLP_DEBUG_C
#if defined (_STLP_DEBUG)
#if defined (_STLP_THREADS)
# if !defined (_STLP_NEED_MUTABLE)
# define _STLP_ACQUIRE_LOCK(_Lock) _Lock._M_acquire_lock();
# define _STLP_RELEASE_LOCK(_Lock) _Lock._M_release_lock();
# else
# define _STLP_ACQUIRE_LOCK(_Lock) ((_STLP_mutex&)_Lock)._M_acquire_lock();
# define _STLP_RELEASE_LOCK(_Lock) ((_STLP_mutex&)_Lock)._M_release_lock();
# endif /* _STLP_NEED_MUTABLE */
#else
# define _STLP_ACQUIRE_LOCK(_Lock)
# define _STLP_RELEASE_LOCK(_Lock)
#endif /* _STLP_THREADS */
_STLP_BEGIN_NAMESPACE
_STLP_MOVE_TO_PRIV_NAMESPACE
//==========================================================
// global non-inline functions
//==========================================================
// [ i1, i2)
#if !defined (__DMC__)
template <class _Iterator>
inline bool _STLP_CALL
__in_range_aux(const _Iterator& __it, const _Iterator& __first,
const _Iterator& __last, const random_access_iterator_tag &) {
return ( __it >= __first &&
__it < __last);
}
#endif
template <class _Iterator1, class _Iterator>
#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1100)
inline bool _STLP_CALL __in_range_aux(_Iterator1 __it, const _Iterator& __first,
#else
inline bool _STLP_CALL __in_range_aux(const _Iterator1& __it, const _Iterator& __first,
#endif
const _Iterator& __last, const forward_iterator_tag &) {
_Iterator1 __i(__first);
for (; __i != __last && __i != __it; ++__i);
return (__i != __last);
}
#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
template <class _Iterator1, class _Iterator>
inline bool _STLP_CALL
__in_range_aux(const _Iterator1& __it, const _Iterator& __first,
const _Iterator& __last, const bidirectional_iterator_tag &) {
_Iterator1 __i(__first);
for (; __i != __last && __i != __it; ++__i);
return (__i != __last);
}
#endif
template <class _Iterator>
bool _STLP_CALL __check_range_aux(const _Iterator& __first, const _Iterator& __last,
const __false_type& /*_IsIntegral*/) {
_STLP_VERBOSE_RETURN(__valid_range(__first,__last), _StlMsg_INVALID_RANGE )
return true;
}
template <class _Integral>
bool _STLP_CALL __check_range_aux(_Integral /*__first*/, _Integral /*__last*/,
const __true_type& /*_IsIntegral*/)
{ return true; }
template <class _Iterator>
bool _STLP_CALL __check_range(const _Iterator& __first, const _Iterator& __last) {
typedef typename _IsIntegral<_Iterator>::_Ret _Integral;
return __check_range_aux(__first, __last, _Integral());
}
template <class _Iterator>
bool _STLP_CALL __check_range(const _Iterator& __it,
const _Iterator& __start, const _Iterator& __finish) {
_STLP_VERBOSE_RETURN(__in_range(__it, __start, __finish),
_StlMsg_NOT_IN_RANGE_1)
return true;
}
template <class _Iterator>
bool _STLP_CALL __check_range(const _Iterator& __first, const _Iterator& __last,
const _Iterator& __start, const _Iterator& __finish) {
_STLP_VERBOSE_RETURN(__in_range(__first, __last, __start, __finish),
_StlMsg_NOT_IN_RANGE_2)
return true;
}
template <class _Tp>
bool _STLP_CALL __check_ptr_range(const _Tp* __first, const _Tp* __last) {
_STLP_VERBOSE_RETURN((__first != 0 || __last == 0), _StlMsg_INVALID_ARGUMENT)
_STLP_VERBOSE_RETURN(__valid_range(__first, __last, random_access_iterator_tag()),
_StlMsg_INVALID_RANGE)
return true;
}
//===============================================================
template <class _Iterator>
void _STLP_CALL __invalidate_range(const __owned_list* __base,
const _Iterator& __first,
const _Iterator& __last) {
typedef __owned_link _L_type;
_STLP_ACQUIRE_LOCK(__base->_M_lock)
_L_type* __prev = __CONST_CAST(_L_type*, &__base->_M_node);
_L_type* __pos = __prev->_M_next;
while (__pos != 0) {
if (!(&__first == __STATIC_CAST(_Iterator*, __pos) || &__last == __STATIC_CAST(_Iterator*, __pos)) &&
__in_range_aux(__STATIC_CAST(_Iterator*, __pos)->_M_iterator,
__first._M_iterator, __last._M_iterator,
_STLP_ITERATOR_CATEGORY(__first, _Iterator))) {
__pos->_M_owner = 0;
__prev->_M_next = __pos->_M_next;
}
else {
__prev = __pos;
}
__pos = __prev->_M_next;
}
_STLP_RELEASE_LOCK(__base->_M_lock)
}
template <class _Iterator>
void _STLP_CALL __invalidate_iterator(const __owned_list* __base,
const _Iterator& __it) {
typedef __owned_link _L_type;
_STLP_ACQUIRE_LOCK(__base->_M_lock)
_L_type* __prev = __CONST_CAST(_L_type*, &__base->_M_node);
_L_type* __pos = __prev->_M_next;
while (__pos != 0) {
// this requires safe iterators to be derived from __owned_link
if ((__pos != __STATIC_CAST(const _L_type*, &__it)) &&
(__STATIC_CAST(_Iterator*, __pos)->_M_iterator == __it._M_iterator)) {
__pos->_M_owner = 0;
__prev->_M_next = __pos->_M_next;
}
else {
__prev = __pos;
}
__pos = __prev->_M_next;
}
_STLP_RELEASE_LOCK(__base->_M_lock)
}
template <class _Iterator>
void _STLP_CALL __change_range_owner(const _Iterator& __first,
const _Iterator& __last,
const __owned_list* __dst) {
if (__first._Owner() == __dst)
return;
typedef __owned_link _L_type;
// Check __stl_debug_engine<_Dummy>::_Swap_owners comments to see why there is no lock here
//_STLP_ACQUIRE_LOCK(__base->_M_lock)
__owned_list *__base = __CONST_CAST(__owned_list*, __first._Owner());
_L_type* __src_prev = &__base->_M_node;
_L_type* __pos = __src_prev->_M_next;
_L_type* __dst_prev = __CONST_CAST(_L_type*, &__dst->_M_node);
while (__pos != 0) {
if (!(&__first == __STATIC_CAST(_Iterator*, __pos) || &__last == __STATIC_CAST(_Iterator*, __pos)) &&
__in_range_aux(__STATIC_CAST(_Iterator*, __pos)->_M_iterator,
__first._M_iterator, __last._M_iterator,
_STLP_ITERATOR_CATEGORY(__first, _Iterator))) {
__pos->_M_owner = __CONST_CAST(__owned_list*, __dst);
//remove __pos from __base:
__src_prev->_M_next = __pos->_M_next;
//add __pos to __dst:
__pos->_M_next = __dst_prev->_M_next;
__dst_prev->_M_next = __pos;
}
else {
__src_prev = __pos;
}
__pos = __src_prev->_M_next;
}
//_STLP_RELEASE_LOCK(__base->_M_lock)
}
template <class _Iterator>
void _STLP_CALL __change_ite_owner(const _Iterator& __it,
const __owned_list* __dst) {
if (__it._Owner() == __dst)
return;
typedef __owned_link _L_type;
// Check __stl_debug_engine<_Dummy>::_Swap_owners comments to see why there is no lock here
//_STLP_ACQUIRE_LOCK(__base->_M_lock)
__owned_list *__base = __CONST_CAST(__owned_list*, __it._Owner());
_L_type* __prev = &__base->_M_node;
_L_type* __pos = __prev->_M_next;
_L_type* __dst_prev = __CONST_CAST(_L_type*, &__dst->_M_node);
while (__pos != 0) {
// this requires safe iterators to be derived from __owned_link
if ((__pos != __STATIC_CAST(const _L_type*, &__it)) &&
(__STATIC_CAST(_Iterator*, __pos)->_M_iterator == __it._M_iterator)) {
__pos->_M_owner = __CONST_CAST(__owned_list*, __dst);
//remove __pos from __base:
__prev->_M_next = __pos->_M_next;
//add __pos to __dst:
__pos->_M_next = __dst_prev->_M_next;
__dst_prev->_M_next = __pos;
}
else {
__prev = __pos;
}
__pos = __prev->_M_next;
}
//_STLP_RELEASE_LOCK(__base->_M_lock)
}
_STLP_MOVE_TO_STD_NAMESPACE
_STLP_END_NAMESPACE
#endif /* _STLP_DEBUG */
#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
# ifndef _STLP_INTERNAL_CSTDLIB
# include <stl/_cstdlib.h>
# endif
//==========================================================
// .c section
// owned_list non-inline methods and global functions
//==========================================================
# if defined (_STLP_ASSERTIONS)
_STLP_BEGIN_NAMESPACE
_STLP_MOVE_TO_PRIV_NAMESPACE
# if !defined (_STLP_STRING_LITERAL)
# define _STLP_STRING_LITERAL(__x) __x
# endif
# if defined (_STLP_USE_WIDE_INTERFACE)
// note: WinCE needs this to format single-byte strings in __stl_debug_engine::_Message
# define _STLP_PERCENT_S "%hs"
# else
# define _STLP_PERCENT_S "%s"
# endif /* _STLP_USE_WIDE_INTERFACE */
# define _STLP_MESSAGE_TABLE_BODY = { \
_STLP_STRING_LITERAL("\n" _STLP_PERCENT_S "(%d): STL error: " _STLP_PERCENT_S "\n"), \
_STLP_STRING_LITERAL(_STLP_PERCENT_S "(%d): STL assertion failure : " _STLP_PERCENT_S "\n" _STLP_ASSERT_MSG_TRAILER), \
_STLP_STRING_LITERAL("\n" _STLP_PERCENT_S "(%d): STL error : " _STLP_PERCENT_S "\n" _STLP_PERCENT_S "(%d): STL assertion failure: " _STLP_PERCENT_S " \n" _STLP_ASSERT_MSG_TRAILER), \
_STLP_STRING_LITERAL("Invalid argument to operation (see operation documentation)"), \
_STLP_STRING_LITERAL("Taking an iterator out of destroyed (or otherwise corrupted) container"), \
_STLP_STRING_LITERAL("Trying to extract an object out from empty container"),\
_STLP_STRING_LITERAL("Past-the-end iterator could not be erased"), \
_STLP_STRING_LITERAL("Index out of bounds"), \
_STLP_STRING_LITERAL("Container doesn't own the iterator"), \
_STLP_STRING_LITERAL("Container is owner of the iterator, but should not"), \
_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) iterator used"), \
_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) lefthand iterator in expression"), \
_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) righthand iterator in expression"), \
_STLP_STRING_LITERAL("Iterators used in expression are from different owners"), \
_STLP_STRING_LITERAL("Iterator could not be dereferenced (past-the-end ?)"), \
_STLP_STRING_LITERAL("Range [first,last) is invalid"), \
_STLP_STRING_LITERAL("Iterator is not in range [first,last)"), \
_STLP_STRING_LITERAL("Range [first,last) is not in range [start,finish)"), \
_STLP_STRING_LITERAL("The advance would produce invalid iterator"), \
_STLP_STRING_LITERAL("Iterator is singular (advanced beyond the bounds ?)"), \
_STLP_STRING_LITERAL("Invalid strict weak ordering predicate, if pred(a, b) then we should have !pred(b, a)"), \
_STLP_STRING_LITERAL("Invalid equivalent predicate, if pred(a, b) then we should have pred(b, a)"), \
_STLP_STRING_LITERAL("Memory block deallocated twice"), \
_STLP_STRING_LITERAL("Deallocating a block that was never allocated"), \
_STLP_STRING_LITERAL("Deallocating a memory block allocated for another type"), \
_STLP_STRING_LITERAL("Size of block passed to deallocate() doesn't match block size"), \
_STLP_STRING_LITERAL("Pointer underrun - safety margin at front of memory block overwritten"), \
_STLP_STRING_LITERAL("Pointer overrrun - safety margin at back of memory block overwritten"), \
_STLP_STRING_LITERAL("Attempt to dereference null pointer returned by auto_ptr::get()"), \
_STLP_STRING_LITERAL("Memory allocation function returned a wrongly align memory block"), \
_STLP_STRING_LITERAL("Unknown problem") \
}
# if (_STLP_STATIC_TEMPLATE_DATA > 0)
template <class _Dummy>
const char* __stl_debug_engine<_Dummy>::_Message_table[_StlMsg_MAX] _STLP_MESSAGE_TABLE_BODY;
# if (defined (__CYGWIN__) || defined (__MINGW32__)) && \
defined (_STLP_USE_DYNAMIC_LIB) && !defined (__BUILDING_STLPORT)
/*
* Under cygwin, when STLport is used as a shared library, the id needs
* to be specified as imported otherwise they will be duplicated in the
* calling executable.
*/
_STLP_TEMPLATE_NULL
_STLP_DECLSPEC const char* __stl_debug_engine<bool>::_Message_table[_StlMsg_MAX];
# endif
# else
__DECLARE_INSTANCE(const char*, __stl_debug_engine<bool>::_Message_table[_StlMsg_MAX],
_STLP_MESSAGE_TABLE_BODY);
# endif
# undef _STLP_STRING_LITERAL
# undef _STLP_PERCENT_S
_STLP_MOVE_TO_STD_NAMESPACE
_STLP_END_NAMESPACE
// abort()
# ifndef _STLP_INTERNAL_CSTDLIB
# include <stl/_cstdlib.h>
# endif
# if !defined (_STLP_DEBUG_MESSAGE)
# ifndef _STLP_INTERNAL_CSTDARG
# include <stl/_cstdarg.h>
# endif
# ifndef _STLP_INTERNAL_CSTDIO
# include <stl/_cstdio.h>
# endif
# if defined (_STLP_DEBUG_MODE_THROWS) && !defined (_STLP_RANGE_ERRORS_H)
# include <stl/_range_errors.h>
# endif
_STLP_BEGIN_NAMESPACE
_STLP_MOVE_TO_PRIV_NAMESPACE
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Message(const char * __format_str, ...) {
STLPORT_CSTD::va_list __args;
va_start( __args, __format_str );
# if !defined (_STLP_DEBUG_MODE_THROWS)
# if defined (_STLP_USE_WIDE_INTERFACE)
TCHAR __buffer[512];
int _convert = strlen(__format_str) + 1;
LPWSTR _lpw = (LPWSTR)alloca(_convert * sizeof(wchar_t));
_lpw[0] = '\0';
MultiByteToWideChar(GetACP(), 0, __format_str, -1, _lpw, _convert);
wvsprintf(__buffer, _lpw, __args);
_STLP_WINCE_TRACE(__buffer);
# elif defined (_STLP_WIN32) && (defined(_STLP_MSVC) || defined (__ICL))
char __buffer [4096];
# if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
vsnprintf(__buffer, _STLP_ARRAY_SIZE(__buffer), __format_str, __args);
# else
vsnprintf_s(__buffer, _STLP_ARRAY_SIZE(__buffer), _TRUNCATE, __format_str, __args);
# endif
OutputDebugStringA(__buffer);
# elif defined (__amigaos__)
STLPORT_CSTD::vfprintf(stderr, __format_str, (char *)__args);
# else
STLPORT_CSTD::vfprintf(stderr, __format_str, __args);
# endif
# else
char __buffer[4096];
# if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
vsnprintf_s(__buffer, _STLP_ARRAY_SIZE(__buffer), _TRUNCATE, __format_str, __args);
# elif defined (_STLP_WIN32) && (defined(_STLP_MSVC) || defined (__ICL))
vsnprintf(__buffer, _STLP_ARRAY_SIZE(__buffer), __format_str, __args);
# else
vsprintf(__buffer, __format_str, __args);
# endif
# endif
# ifdef _STLP_DEBUG_MESSAGE_POST
_STLP_DEBUG_MESSAGE_POST
# endif
va_end(__args);
# if defined (_STLP_DEBUG_MODE_THROWS)
__stl_throw_runtime_error(__buffer);
# endif
}
_STLP_MOVE_TO_STD_NAMESPACE
_STLP_END_NAMESPACE
# else
_STLP_BEGIN_NAMESPACE
_STLP_MOVE_TO_PRIV_NAMESPACE
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Message(const char * __format_str, ...)
{}
_STLP_MOVE_TO_STD_NAMESPACE
_STLP_END_NAMESPACE
# endif /* _STLP_DEBUG_MESSAGE */
_STLP_BEGIN_NAMESPACE
_STLP_MOVE_TO_PRIV_NAMESPACE
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_IndexedError(int __error_ind, const char* __f, int __l) {
__stl_debug_message(_Message_table[_StlFormat_ERROR_RETURN],
__f, __l, _Message_table[__error_ind]);
}
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_VerboseAssert(const char* __expr, int __error_ind, const char* __f, int __l) {
__stl_debug_message(_Message_table[_StlFormat_VERBOSE_ASSERTION_FAILURE],
__f, __l, _Message_table[__error_ind], __f, __l, __expr);
__stl_debug_terminate();
}
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Assert(const char* __expr, const char* __f, int __l) {
__stl_debug_message(_Message_table[_StlFormat_ASSERTION_FAILURE],__f, __l, __expr);
__stl_debug_terminate();
}
// if exceptions are present, sends unique exception
// if not, calls abort() to terminate
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Terminate()
{ _STLP_ABORT(); }
_STLP_MOVE_TO_STD_NAMESPACE
_STLP_END_NAMESPACE
# endif /* _STLP_ASSERTIONS */
# if defined (_STLP_DEBUG)
_STLP_BEGIN_NAMESPACE
_STLP_MOVE_TO_PRIV_NAMESPACE
//==========================================================
// owned_list non-inline methods
//==========================================================
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Invalidate_all(__owned_list* __l) {
_STLP_ACQUIRE_LOCK(__l->_M_lock);
_Stamp_all(__l, 0);
__l->_M_node._M_next =0;
_STLP_RELEASE_LOCK(__l->_M_lock);
}
// boris : this is unasafe routine; should be used from within critical section only !
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Stamp_all(__owned_list* __l, __owned_list* __o) {
// crucial
if (__l->_M_node._M_owner) {
for (__owned_link* __pos = (__owned_link*)__l->_M_node._M_next;
__pos != 0; __pos = (__owned_link*)__pos->_M_next) {
_STLP_ASSERT(__pos->_Owner()== __l)
__pos->_M_owner=__o;
}
}
}
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Verify(const __owned_list* __l) {
_STLP_ACQUIRE_LOCK(__l->_M_lock);
if (__l) {
_STLP_ASSERT(__l->_M_node._Owner() != 0)
for (__owned_link* __pos = (__owned_link*)__l->_M_node._M_next;
__pos != 0; __pos = (__owned_link*)__pos->_M_next) {
_STLP_ASSERT(__pos->_Owner()== __l)
}
}
_STLP_RELEASE_LOCK(__l->_M_lock);
}
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Swap_owners(__owned_list& __x, __owned_list& __y) {
/*
* according to the standard : --no swap() function invalidates any references,
* pointers, or iterators referring to the elements of the containers being swapped.
*/
__owned_link* __tmp;
/*
* boris : there is a deadlock potential situation here if we lock two containers sequentially.
* As user is supposed to provide its own synchronization around swap() ( it is unsafe to do any container/iterator access
* in parallel with swap()), we just do not use any locking at all -- that behaviour is closer to non-debug version
*/
__tmp = __x._M_node._M_next;
_Stamp_all(&__x, &__y);
_Stamp_all(&__y, &__x);
__x._M_node._M_next = __y._M_node._M_next;
__y._M_node._M_next = __tmp;
}
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_Set_owner(__owned_list& __src, __owned_list& __dst) {
if (&__src == &__dst)
return;
// Check __stl_debug_engine<_Dummy>::_Swap_owners comments to see why there is no lock here
typedef __owned_link _L_type;
_L_type* __prev = &__src._M_node;
_L_type* __pos = __prev->_M_next;
while (__pos != 0) {
__pos->_M_owner = &__dst;
__prev = __pos;
__pos = __prev->_M_next;
}
__prev->_M_next = __dst._M_node._M_next;
__dst._M_node._M_next = __src._M_node._M_next;
__src._M_node._M_next = 0;
}
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_M_detach(__owned_list* __l, __owned_link* __c_node) {
if (__l != 0) {
_STLP_VERBOSE_ASSERT(__l->_Owner()!=0, _StlMsg_INVALID_CONTAINER)
_STLP_ACQUIRE_LOCK(__l->_M_lock)
// boris : re-test the condition in case someone else already deleted us
if(__c_node->_M_owner != 0) {
__owned_link* __prev, *__next;
for (__prev = &__l->_M_node; (__next = __prev->_M_next) != __c_node;
__prev = __next) {
_STLP_ASSERT(__next && __next->_Owner() == __l)
}
__prev->_M_next = __c_node->_M_next;
__c_node->_M_owner=0;
}
_STLP_RELEASE_LOCK(__l->_M_lock)
}
}
template <class _Dummy>
void _STLP_CALL
__stl_debug_engine<_Dummy>::_M_attach(__owned_list* __l, __owned_link* __c_node) {
if (__l ==0) {
(__c_node)->_M_owner = 0;
} else {
_STLP_VERBOSE_ASSERT(__l->_Owner()!=0, _StlMsg_INVALID_CONTAINER)
_STLP_ACQUIRE_LOCK(__l->_M_lock)
__c_node->_M_owner = __l;
__c_node->_M_next = __l->_M_node._M_next;
__l->_M_node._M_next = __c_node;
_STLP_RELEASE_LOCK(__l->_M_lock)
}
}
template <class _Dummy>
void* _STLP_CALL
__stl_debug_engine<_Dummy>::_Get_container_ptr(const __owned_link* __l) {
const __owned_list* __owner = __l->_Owner();
_STLP_VERBOSE_RETURN_0(__owner != 0, _StlMsg_INVALID_ITERATOR)
void* __ret = __CONST_CAST(void*,__owner->_Owner());
_STLP_VERBOSE_RETURN_0(__ret !=0, _StlMsg_INVALID_CONTAINER)
return __ret;
}
template <class _Dummy>
bool _STLP_CALL
__stl_debug_engine<_Dummy>::_Check_same_owner(const __owned_link& __i1,
const __owned_link& __i2) {
_STLP_VERBOSE_RETURN(__i1._Valid(), _StlMsg_INVALID_LEFTHAND_ITERATOR)
_STLP_VERBOSE_RETURN(__i2._Valid(), _StlMsg_INVALID_RIGHTHAND_ITERATOR)
_STLP_VERBOSE_RETURN((__i1._Owner() == __i2._Owner()), _StlMsg_DIFFERENT_OWNERS)
return true;
}
template <class _Dummy>
bool _STLP_CALL
__stl_debug_engine<_Dummy>::_Check_same_or_null_owner(const __owned_link& __i1,
const __owned_link& __i2) {
_STLP_VERBOSE_RETURN(__i1._Owner() == __i2._Owner(), _StlMsg_DIFFERENT_OWNERS)
return true;
}
template <class _Dummy>
bool _STLP_CALL
__stl_debug_engine<_Dummy>::_Check_if_owner( const __owned_list * __l, const __owned_link& __it) {
const __owned_list* __owner_ptr = __it._Owner();
_STLP_VERBOSE_RETURN(__owner_ptr != 0, _StlMsg_INVALID_ITERATOR)
_STLP_VERBOSE_RETURN(__l == __owner_ptr, _StlMsg_NOT_OWNER)
return true;
}
template <class _Dummy>
bool _STLP_CALL
__stl_debug_engine<_Dummy>::_Check_if_not_owner( const __owned_list * __l, const __owned_link& __it) {
const __owned_list* __owner_ptr = __it._Owner();
_STLP_VERBOSE_RETURN(__owner_ptr != 0, _StlMsg_INVALID_ITERATOR)
_STLP_VERBOSE_RETURN(__l != __owner_ptr, _StlMsg_SHOULD_NOT_OWNER)
return true;
}
_STLP_MOVE_TO_STD_NAMESPACE
_STLP_END_NAMESPACE
# endif /* _STLP_DEBUG */
#endif /* if defined (EXPOSE_GLOBALS_IMPLEMENTATION) */
#endif /* header guard */
// Local Variables:
// mode:C++
// End:
|
the_stack_data/6387755.c | #include<stdio.h>
int main()
{
int bt[20],p[20],wt[20],tat[20],pr[20],i,j,n,total=0,pos,temp,avg_wt,avg_tat;
printf("Enter Total Number of Process:");
scanf("%d",&n);
printf("\nEnter Burst Time and Priority\n");
for(i=0;i<n;i++)
{
printf("\nP[%d]\n",i+1);
printf("Burst Time:");
scanf("%d",&bt[i]);
printf("Priority:");
scanf("%d",&pr[i]);
p[i]=i+1; //contains process number
}
//sorting burst time, priority and process number in ascending order using selection sort
for(i=0;i<n;i++)
{
pos=i;
for(j=i+1;j<n;j++)
{
if(pr[j]<pr[pos])
pos=j;
}
temp=pr[i];
pr[i]=pr[pos];
pr[pos]=temp;
temp=bt[i];
bt[i]=bt[pos];
bt[pos]=temp;
temp=p[i];
p[i]=p[pos];
p[pos]=temp;
}
wt[0]=0; //waiting time for first process is zero
//calculate waiting time
for(i=1;i<n;i++)
{
wt[i]=0;
for(j=0;j<i;j++)
wt[i]+=bt[j];
total+=wt[i];
}
avg_wt=total/n; //average waiting time
total=0;
printf("\nProcess\t Burst Time \tWaiting Time\tTurnaround Time");
for(i=0;i<n;i++)
{
tat[i]=bt[i]+wt[i]; //calculate turnaround time
total+=tat[i];
printf("\nP[%d]\t\t %d\t\t %d\t\t\t%d",p[i],bt[i],wt[i],tat[i]);
}
avg_tat=total/n; //average turnaround time
printf("\n\nAverage Waiting Time=%d",avg_wt);
printf("\nAverage Turnaround Time=%d\n",avg_tat);
return 0;
} |
the_stack_data/87638525.c | /*************************************************************************\
* Copyright (C) Michael Kerrisk, 2014. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU Affero General Public License as published *
* by the Free Software Foundation, either version 3 or (at your option) *
* any later version. This program is distributed without any warranty. *
* See the file COPYING.agpl-v3 for details. *
\*************************************************************************/
#include <stdio.h>
void xyz(void) { printf("v1 xyz()\n"); }
|
the_stack_data/140766342.c | /* Taxonomy Classification: 0000000100000054000110 */
/*
* WRITE/READ 0 write
* WHICH BOUND 0 upper
* DATA TYPE 0 char
* MEMORY LOCATION 0 stack
* SCOPE 0 same
* CONTAINER 0 no
* POINTER 0 no
* INDEX COMPLEXITY 1 variable
* ADDRESS COMPLEXITY 0 constant
* LENGTH COMPLEXITY 0 N/A
* ADDRESS ALIAS 0 none
* INDEX ALIAS 0 none
* LOCAL CONTROL FLOW 0 none
* SECONDARY CONTROL FLOW 0 none
* LOOP STRUCTURE 5 non-standard do-while
* LOOP COMPLEXITY 4 three
* ASYNCHRONY 0 no
* TAINT 0 no
* RUNTIME ENV. DEPENDENCE 0 no
* MAGNITUDE 1 1 byte
* CONTINUOUS/DISCRETE 1 continuous
* SIGNEDNESS 0 no
*/
/*
Copyright 2005 Massachusetts Institute of Technology
All rights reserved.
Redistribution and use of software in source and binary forms, with or without
modification, are permitted provided that the following conditions are met.
- Redistributions of source code must retain the above copyright notice,
this set of conditions and the disclaimer below.
- Redistributions in binary form must reproduce the copyright notice, this
set of conditions, and the disclaimer below in the documentation and/or
other materials provided with the distribution.
- Neither the name of the Massachusetts Institute of Technology nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS".
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
int main(int argc, char *argv[])
{
int init_value;
int test_value;
int inc_value;
int loop_counter;
char buf[10];
init_value = 0;
test_value = 10;
inc_value = 10 - (10 - 1);
loop_counter = init_value;
do
{
/* BAD */
buf[loop_counter] = 'A';
}
while((loop_counter += inc_value) && (loop_counter <= test_value));
return 0;
}
|
the_stack_data/35140.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <omp.h>
#include <math.h>
void readMatrix(double** matrix, FILE* file, int n);
void printMatrix(double **matrix, int n, FILE* file);
double determinant(double **l, double **u, int n, int *perm);
void forwardSubstitution(double **l, double **p, double *y, int column, int n);
void backwardSubstitution(double **u, double *y, double **a_inv, int column, int n);
void pivoting(double **a, double **p, int n, int *perm);
void decomposition(double **l, double **u, int n);
/*
* The file which contains a matrix has in its first row the dimensions
* then using fscanf each element of the matrix is stored on the memory allocated dynamically
*/
void readMatrix(double** matrix, FILE* file, int n) {
int i, j;
for (i = 0; i < n; i++){
matrix[i] = (double*)malloc(n * sizeof(double));
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
fscanf(file, "%lf", &matrix[i][j]);
}
}
}
/* The opposite operation of readMatrix. Stores a matrix into a file, element by element */
void printMatrix(double **matrix, int n, FILE* file) {
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
fprintf(file, "%lf ", matrix[i][j]);
}
fprintf(file, "\n");
}
}
/*
* Because LU decomposition is used, det M = det LU = det L * det U.
* L and U are triangular so the determinant is calculated as the product of the diagonal elements
*/
double determinant(double **l, double **u, int n, int *perm) {
int i;
double det = 1;
#pragma omp parallel
{
#pragma omp for reduction(*: det) //to speedup computation we apply the reduction to det. In this way the iteration are distributed among threads and at the end the final det value is calculated with a parallel reduction
for(i = 0; i < n; i++)
det *= l[i][i] * u[i][i];
}
return pow(-1, perm[0]) * det; //it is necessary to multiply the obtained the with (-1) raised to the number of permutation occurred in pivoting
}
/* Since L is a lower triangular matrix forward substitution is used to perform the calculus of Lx=y */
void forwardSubstitution(double **l, double **p, double *y, int column, int n) {
int i, j;
double sum = 0;
for (i = 0; i < n; i++) {
//#pragma omp parallel for reduction(+:sum) //another way of parallelizing spreading the work for each linear equation among threads but it is better to do a parallelizazione as done in the for loop in main
for (j = 0; j < i; j++) {
sum = sum + l[i][j] * y[j];
}
y[i] = (p[i][column] - sum) / l[i][i];
sum = 0;
}
}
/* Since U is an upper triangular matrix backward substitution is used to perform the calculus of Ux=y */
void backwardSubstitution(double **u, double *y, double **a_inv, int column, int n) {
int i, j;
double sum;
a_inv[n-1][column] = y[n-1] / u[n-1][n-1];
for (i = n - 2; i >= 0; i--) {
sum = y[i];
//#pragma omp parallel for reduction(+:sum) //as above
for (j = n - 1; j > i; j--) {
sum = sum - u[i][j] * a_inv[j][column];
}
a_inv[i][column] = sum / u[i][i];
sum = 0;
}
}
/* Even if det(M)!=0, pivoting is performed to be sure that L and U are correctly upper and lower triangular matrix */
void pivoting(double **a, double **p, int n, int *perm) {
int j, k;
int isMaximum = 0;
double *temp = (double*)malloc(n * sizeof(double));
// k is column and j is row
for (k = 0; k < n-1; k++) {
int imax = k;
for (j = k; j < n; j++) {
if (a[j][k] > a[imax][k]) { // finding the maximum index
imax = j;
isMaximum = 1;
}
}
if (isMaximum == 1) {
// swapping a[k] and a[imax]
memcpy(temp, a[k], n * sizeof(double));
memcpy(a[k], a[imax], n * sizeof(double));
memcpy(a[imax], temp, n * sizeof(double));
// swapping p[k] and p[imax]
memcpy(temp, p[k], n * sizeof(double));
memcpy(p[k], p[imax], n * sizeof(double));
memcpy(p[imax], temp, n * sizeof(double));
isMaximum = 0;
perm[0]++;
}
}
free(temp);
}
/* Perf LU decomposition of matrix M to obtain matrices L (lower) and U (upper) used to resolve and equation system throud BW and FW to obtain the inverse */
void decomposition(double **l, double **u, int n) {
int i, j, k;
#pragma omp parallel private (i,j,k)
{
for (k = 0; k < n; k++) { //u is shared, parallelizing this for loop is not possibile because otherwise there will be data races with u
#pragma omp for schedule(static) //computation of rows of l and u are done in parallel with different threads
for (i = k + 1; i < n; i++) {
l[i][k] = u[i][k] / u[k][k];
for (j = k; j < n; j++) {
u[i][j] = u[i][j] - l[i][k] * u[k][j];
}
}
}
}
}
int main(int argc, char* argv[]) {
if(argc != 2) { //Checking parameters: 1.mat_inv.exe 2.matrix.txt
printf("Parameters error.\n");
exit(1);
}
FILE *mat, *resultFile;
double t;
int i, rows, cols, perm = 0;
mat = fopen(argv[1], "r");
fscanf(mat, "%d %d", &rows, &cols);
if (rows != cols) {
printf("ERROR: It is not possible to compute the inversion: the matrix is not squared\n");
fclose(mat);
exit(1);
}
int n = rows; //matrix order (m is squared)
double **m = (double **)malloc(n * sizeof(double*));
readMatrix(m, mat, n);
//printf("\nThe matrix you have inserted is %dx%d and has %d elements\nPlease wait until computation are done...\n\n", n, n, n * n);
/* Create pivoting and inverse matrices and matrices initialization */
double **a_inv = (double **)malloc(n * sizeof(double*));
double **p = (double **)malloc(n * sizeof(double*));
double **l = (double **)malloc(n * sizeof(double*));
double **a_p = (double **)malloc(n * sizeof(double*));
double **u = (double **)malloc(n * sizeof(double*));
#pragma omp parallel for //spread initialization work but it not speedup a lot the code so it was ignored in wall clock time measures
for(i = 0; i < n; i++) {
a_inv[i] = (double *)malloc(n * sizeof(double));
p[i] = (double *)malloc(n * sizeof(double));
l[i] = (double *)malloc(n * sizeof(double));
a_p[i] = (double *)malloc(n * sizeof(double));
u[i] = (double *)malloc(n * sizeof(double));
memset(a_inv[i], 0, n * sizeof(double));
memset(p[i], 0, n * sizeof(double));
memset(l[i], 0, n * sizeof(double));
memset(u[i], 0, n * sizeof(double));
memcpy(a_p[i], m[i], n * sizeof(double));
p[i][i] = 1;
l[i][i] = 1;
}
/* START */
t = omp_get_wtime();
pivoting(a_p, p, n, &perm);
#pragma omp parallel for
for (i = 0; i < n; i++){
memcpy(u[i], a_p[i], n * sizeof(double)); // Fill u using a_p elements
}
decomposition(l, u, n);
double det = determinant(l, u, n, &perm);
printf("Determinant: %lf\n", det);
if(det == 0.0) {
printf("ERROR: It is not possible to compute the inversion: determinant is equal to 0\n");
fclose(mat);
for (i = 0; i < n; i++) {
free(p[i]);
free(a_p[i]);
free(u[i]);
free(l[i]);
free(a_inv[i]);
free(m[i]);
}
free(p);
free(l);
free(u);
free(a_p);
free(a_inv);
free(m);
exit(1);
}
/* Finding the inverse, result is stored into a_inv */
#pragma omp parallel shared(a_inv) private(i)
{
#pragma omp for schedule(dynamic)
for (i = 0; i < n; i++) {
double *y = (double*)malloc(n * sizeof(double));
forwardSubstitution(l, p, y, i, n); // y is filled
backwardSubstitution(u, y, a_inv, i, n); // a_inv is filled
free(y);
}
}
t = omp_get_wtime() - t;
/* STOP */
resultFile = fopen("inverse.txt", "w");
printMatrix(a_inv, n, resultFile);
printf("Elapsed time: %lf seconds\n", t);
fclose(mat);
fclose(resultFile);
for (i = 0; i < n; i++) {
free(p[i]);
free(a_p[i]);
free(u[i]);
free(l[i]);
free(a_inv[i]);
free(m[i]);
}
free(p);
free(l);
free(u);
free(a_p);
free(a_inv);
free(m);
return 0;
}
|
the_stack_data/12606.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcpy_main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: muhozkan <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/02/25 23:47:11 by muhozkan #+# #+# */
/* Updated: 2022/02/25 23:47:11 by muhozkan ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdio.h>
void *ft_memcpy(void *dest, const void *src, size_t n);
int main()
{
unsigned char src[] = " world!";
unsigned char dst[] = "hello";
ft_memcpy(dst+5, src, 8);
printf("%s", dst);
} |
the_stack_data/231393363.c | /*
* Copyright (C) 2015-2017 Alibaba Group Holding Limited
*/
#include "mqueue.h"
#if (POSIX_CONFIG_MQUEUE_ENABLE > 0)
mqd_t mq_open(const char *name, int oflag, ...)
{
kbuf_queue_t *mq;
kstat_t ret;
ret = krhino_buf_queue_dyn_create(&mq, "buf_queue", DEFAULT_MQUEUE_SIZE, DEFAULT_MAX_MSG_SIZE);
if (ret != RHINO_SUCCESS) {
return 0;
}
return mq;
}
int mq_close(mqd_t mqdes)
{
return krhino_buf_queue_dyn_del(mqdes);
}
ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio)
{
size_t msg_size;
kstat_t ret;
*msg_prio = 0;
ret = krhino_buf_queue_recv(mqdes, 0, msg_ptr, &msg_size);
if (ret != RHINO_SUCCESS) {
return 0;
}
return msg_size;
}
int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio)
{
kstat_t ret;
ret = krhino_buf_queue_send((kbuf_queue_t *)mqdes, (void *)msg_ptr, msg_len);
if (ret != RHINO_SUCCESS) {
return 0;
}
return msg_len;
}
int mq_setattr(mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat)
{
return 0;
}
int mq_getattr(mqd_t mqdes, struct mq_attr *mqstat)
{
return 0;
}
ssize_t mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
unsigned *msg_prio, const struct timespec *abs_timeout)
{
size_t msg_size;
kstat_t ret;
tick_t ticks;
*msg_prio = 0;
ticks = abs_timeout->tv_sec * RHINO_CONFIG_TICKS_PER_SECOND +
(abs_timeout->tv_nsec * RHINO_CONFIG_TICKS_PER_SECOND) / NANOSECONDS_PER_SECOND;
ret = krhino_buf_queue_recv(mqdes, ticks, msg_ptr, &msg_size);
if (ret != RHINO_SUCCESS) {
return 0;
}
return msg_size;
}
int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
unsigned msg_prio, const struct timespec *abs_timeout)
{
kstat_t ret;
(void)msg_prio;
ret = krhino_buf_queue_send((kbuf_queue_t *)mqdes, (void *)msg_ptr, msg_len);
if (ret != RHINO_SUCCESS) {
return 0;
}
return msg_len;
}
#endif
|
the_stack_data/117327912.c | #include <stdio.h>
# define n 10
int linearFind(){
// linear-find
int arr[n] = {0,3,5,6,4,2,9,7,8,1};
int findData = 5;
int idx = -1;
for (int i = 0; i < n; ++i) {
if(arr[i] == findData){
idx = i;
}
}
if(idx == -1){
printf("Do not find the value1\n");
}
else {
printf("idx = %d\n", idx);
}
return 0;
}
int halfFoldSearch(){
int arr[n] = {0,1,2,3,4,5,6,7,8,9};
int findData = 5;
int low = 0;
int high = n-1;
int midIndex = -1;
int idx = -1;
while(low <= high){
midIndex = (low+high)/2;
if(findData == arr[midIndex]){
idx = midIndex;
break;
}
else if(findData > arr[midIndex]){
low = midIndex + 1;
}else{
high = midIndex - 1;
}
}
if(idx != -1){
printf("idx = %d\n", idx);
}
else{
printf("find none\n");
}
return 0;
}
int main()
{// find algorithm
linearFind();
halfFoldSearch();
return 0;
}
|
the_stack_data/48574028.c | #include<stdio.h>
int main(int argc, char const *argv[]) {
unsigned int n,i,j,k,count=0;
scanf("%u",&n);
while(n--)
{
scanf("%u %u",&i,&j);
count=0;
while(i!=j)
{
i>>=1;
j>>=1;
count++;
}
i<<=count;
printf("%u\n",i);
}
return 0;
}
|
the_stack_data/123635.c | /*Create a Stack using array implementation with functions: push(),
pop and tos. Write a function display_stack to print all elements.*/
#include<stdio.h>
#include<stdlib.h>
#define size 100
int top = -1;
int push(int *, int);
void pop(void);
int tos(int *);
void display(int *);
int main()
{
int i, n, ch, num, data, arr[size], value=0;
do
{
printf("\n\n\n-----------Stack using array------------:");
printf("\n\n1. Push the element.\n");
printf("\n2. Pop the element.\n");
printf("\n3. top of stack\n");
printf("\n4. Display\n");
printf("\n0. Exit\n");
printf("\nEnter the choice :");
scanf("%d", &ch);
switch(ch)
{
case 1:printf("\nEnter the number n : ");
scanf("%d", &n);
for(i=0; i<n; i++)
{
printf("\nEnter the value to be insert: ");
scanf(" %d", &num);
value = push(arr, num);
}
display(arr);
break;
case 2:pop();
display(arr);
break;
case 3:data =tos(arr);
printf("\nThe element at top is %d.\n", data);
break;
case 4:display(arr);
break;
case 0:exit(1);
default :printf("\nInvalid Input\n");
}
}while(ch > 0);
printf("\n");
return 0;
}
int push(int *arr, int num)
{
if(top == size)
{
printf("\nError: stack overflow..\n");
exit(1);
}
top++;
arr[top] = num;
return top;
}
void pop(void)
{
if(top == -1)
{
printf("\nError: No element to pop ..\n");
exit(1);
}
top--;
}
int tos(int *arr)
{
return arr[top];
}
void display(int *arr)
{
if(top == -1)
printf("\nStack is empty\n");
else
{
printf("\nStack element(s) are :: ");
for(int i = top; i>=0; i--)
printf(" %d\t", arr[i]);
}
}
|
the_stack_data/104173.c | /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is msdump2symdb.c code, released
* Jan 16, 2003.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Garrett Arch Blythe, 16-January-2003
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <errno.h>
#define ERROR_REPORT(num, val, msg) fprintf(stderr, "error(%d):\t\"%s\"\t%s\n", (num), (val), (msg));
#define CLEANUP(ptr) do { if(NULL != ptr) { free(ptr); ptr = NULL; } } while(0)
typedef struct __struct_Options
/*
** Options to control how we perform.
**
** mProgramName Used in help text.
** mInput File to read for input.
** Default is stdin.
** mInputName Name of the file.
** mOutput Output file, append.
** Default is stdout.
** mOutputName Name of the file.
** mHelp Whether or not help should be shown.
*/
{
const char* mProgramName;
FILE* mInput;
char* mInputName;
FILE* mOutput;
char* mOutputName;
int mHelp;
}
Options;
typedef struct __struct_Switch
/*
** Command line options.
*/
{
const char* mLongName;
const char* mShortName;
int mHasValue;
const char* mValue;
const char* mDescription;
}
Switch;
#define DESC_NEWLINE "\n\t\t"
static Switch gInputSwitch = {"--input", "-i", 1, NULL, "Specify input file." DESC_NEWLINE "stdin is default."};
static Switch gOutputSwitch = {"--output", "-o", 1, NULL, "Specify output file." DESC_NEWLINE "Appends if file exists." DESC_NEWLINE "stdout is default."};
static Switch gHelpSwitch = {"--help", "-h", 0, NULL, "Information on usage."};
static Switch* gSwitches[] = {
&gInputSwitch,
&gOutputSwitch,
&gHelpSwitch
};
typedef struct __struct_MSDump_Symbol
/*
** Struct to hold infomration on a symbol.
**
** mSize Size of the symbol once all work is complete.
** mOffset Offset of the symbol in the section.
** mName Symbolic name.
*/
{
unsigned mSize;
unsigned mOffset;
char* mName;
}
MSDump_Symbol;
typedef struct __struct_MSDump_Section
/*
** Struct for holding information on a section.
**
** mLength Length of the section in bytes.
** mUsed Number of bytes used in the section thus far.
** Should eventually match mLength after work is done.
** mType Type of section, as string (.data, .text, et. al.)
** mSymbols Symbols found inside the section.
** mSymbolCount Number of symbols in array.
*/
{
unsigned mLength;
unsigned mUsed;
char* mType;
MSDump_Symbol* mSymbols;
unsigned mSymbolCount;
}
MSDump_Section;
typedef struct __struct_MSDump_Object
/*
** Struct for holding object's data.
*/
{
char* mObject;
MSDump_Section* mSections;
unsigned mSectionCount;
}
MSDump_Object;
typedef struct __struct_MSDump_ReadState
/*
** State flags while reading the input gives us hints on what to do.
**
** mSkipLines Number of lines to skip without parsing.
** mSectionDetails Section information next, like line length.
** mCurrentObject Object file we are dealing with.
*/
{
unsigned mSkipLines;
unsigned mSectionDetails;
MSDump_Object* mCurrentObject;
}
MSDump_ReadState;
typedef struct __struct_MSDump_Container
/*
** Umbrella container for all data encountered.
*/
{
MSDump_ReadState mReadState;
MSDump_Object* mObjects;
unsigned mObjectCount;
}
MSDump_Container;
void trimWhite(char* inString)
/*
** Remove any whitespace from the end of the string.
*/
{
int len = strlen(inString);
while(len)
{
len--;
if(isspace(*(inString + len)))
{
*(inString + len) = '\0';
}
else
{
break;
}
}
}
const char* skipWhite(const char* inString)
/*
** Return pointer to first non white space character.
*/
{
const char* retval = inString;
while('\0' != *retval && isspace(*retval))
{
retval++;
}
return retval;
}
const char* skipNonWhite(const char* inString)
/*
** Return pointer to first white space character.
*/
{
const char* retval = inString;
while('\0' != *retval && !isspace(*retval))
{
retval++;
}
return retval;
}
void slash2bs(char* inString)
/*
** Change any forward slash to a backslash.
*/
{
char* slash = inString;
while(NULL != (slash = strchr(slash, '/')))
{
*slash = '\\';
slash++;
}
}
const char* skipToArg(const char* inString, unsigned inArgIndex)
/*
** Return pointer either to the arg or NULL.
** 1 indexed.
*/
{
const char* retval = NULL;
while(0 != inArgIndex && '\0' != *inString)
{
inArgIndex--;
inString = skipWhite(inString);
if(0 != inArgIndex)
{
inString = skipNonWhite(inString);
}
}
if('\0' != *inString)
{
retval = inString;
}
return retval;
}
const char* getLastArg(const char* inString)
/*
** Return pointer to last arg in string.
*/
{
const char* retval = NULL;
int length = 0;
int sawString = 0;
length = strlen(inString);
while(0 != length)
{
length--;
if(0 == sawString)
{
if(0 == isspace(inString[length]))
{
sawString = __LINE__;
}
}
else
{
if(0 != isspace(inString[length]))
{
retval = inString + length + 1;
}
}
}
return retval;
}
int processLine(Options* inOptions, MSDump_Container* inContainer, const char* inLine)
/*
** Handle one line at a time.
** Looking for several different types of lines.
** Ignore all other lines.
** The container is the state machine.
** returns 0 on no error.
*/
{
int retval = 0;
/*
** Check to see if we were expecting section details.
*/
if(0 != inContainer->mReadState.mSectionDetails)
{
const char* length = NULL;
unsigned sectionIndex = 0;
/*
** Detail is a 1 based index....
** Reset.
*/
sectionIndex = inContainer->mReadState.mSectionDetails - 1;
inContainer->mReadState.mSectionDetails = 0;
if(0 == strncmp(" Section length", inLine, 18))
{
const char* sectionLength = NULL;
unsigned numericLength = 0;
char* endScan = NULL;
sectionLength = skipWhite(inLine + 18);
errno = 0;
numericLength = strtoul(sectionLength, &endScan, 16);
if(0 == errno && endScan != sectionLength)
{
inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mLength = numericLength;
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Cannot scan for section length.");
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Cannot parse section line.");
}
}
/*
** Check for switching object file symbols.
*/
else if(0 == strncmp("Dump of file ", inLine, 13))
{
const char* dupMe = inLine + 13;
char* dup = NULL;
dup = strdup(dupMe);
if(NULL != dup)
{
void* growth = NULL;
trimWhite(dup);
slash2bs(dup);
growth = realloc(inContainer->mObjects, (inContainer->mObjectCount + 1) * sizeof(MSDump_Object));
if(NULL != growth)
{
unsigned int index = inContainer->mObjectCount;
inContainer->mObjectCount++;
inContainer->mObjects = growth;
memset(inContainer->mObjects + index, 0, sizeof(MSDump_Object));
inContainer->mObjects[index].mObject = dup;
/*
** Reset the read state for this new object.
*/
memset(&inContainer->mReadState, 0, sizeof(MSDump_ReadState));
/*
** Record our current object file.
*/
inContainer->mReadState.mCurrentObject = inContainer->mObjects + index;
/*
** We can skip a few lines.
*/
inContainer->mReadState.mSkipLines = 4;
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, dup, "Unable to grow object array.");
free(dup);
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, dupMe, "Unable to copy string.");
}
}
/*
** Check for a symbol dump or a section header.
*/
else if(isxdigit(*inLine) && isxdigit(*(inLine + 1)) && isxdigit(*(inLine + 2)))
{
const char* sectionString = NULL;
/*
** Determine the section for this line.
** Ignore DEBUG sections.
*/
sectionString = skipToArg(inLine, 3);
if(NULL != sectionString)
{
if(0 != strncmp(sectionString, "DEBUG", 5) && 0 != strncmp(sectionString, "ABS", 3) && 0 != strncmp(sectionString, "UNDEF", 5))
{
/*
** MUST start with "SECT"
*/
if(0 == strncmp(sectionString, "SECT", 4))
{
unsigned sectionIndex1 = 0;
char *endScan = NULL;
sectionString += 4;
/*
** Convert the remaining string to an index.
** It will be 1 based.
*/
errno = 0;
sectionIndex1 = strtoul(sectionString, &endScan, 16);
if(0 == errno && endScan != sectionString && 0 != sectionIndex1)
{
unsigned sectionIndex = sectionIndex1 - 1;
/*
** Is this a new section? Assumed to be ascending.
** Or is this a symbol in the section?
*/
if(sectionIndex1 > inContainer->mReadState.mCurrentObject->mSectionCount)
{
const char* typeArg = NULL;
/*
** New Section, figure out the type.
*/
typeArg = skipToArg(sectionString, 5);
if(NULL != typeArg)
{
char* typeDup = NULL;
/*
** Skip the leading period before duping.
*/
if('.' == *typeArg)
{
typeArg++;
}
typeDup = strdup(typeArg);
if(NULL != typeDup)
{
void* moved = NULL;
char* nonWhite = NULL;
/*
** Terminate the duplicate after the section type.
*/
nonWhite = (char*)skipNonWhite(typeDup);
if(NULL != nonWhite)
{
*nonWhite = '\0';
}
/*
** Create more space for the section in the object...
*/
moved = realloc(inContainer->mReadState.mCurrentObject->mSections, sizeof(MSDump_Section) * sectionIndex1);
if(NULL != moved)
{
unsigned oldCount = inContainer->mReadState.mCurrentObject->mSectionCount;
inContainer->mReadState.mCurrentObject->mSections = (MSDump_Section*)moved;
inContainer->mReadState.mCurrentObject->mSectionCount = sectionIndex1;
memset(&inContainer->mReadState.mCurrentObject->mSections[oldCount], 0, sizeof(MSDump_Section) * (sectionIndex1 - oldCount));
/*
** Other section details.
*/
inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mType = typeDup;
/*
** Mark it so that we look for the length on the next line.
** This happens on next entry into the read state.
*/
inContainer->mReadState.mSectionDetails = sectionIndex1;
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Unable to grow for new section.");
free(typeDup);
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, typeArg, "Unable to duplicate type.");
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Unable to determine section type.");
}
}
else
{
const char* offsetArg = NULL;
const char* classArg = NULL;
unsigned classWords = 1;
const char* symbolArg = NULL;
/*
** This is an section we've seen before, and must list a symbol.
** Figure out the things we want to know about the symbol, e.g. size.
** We will ignore particular classes of symbols.
*/
offsetArg = skipToArg(inLine, 2);
classArg = skipToArg(offsetArg, 4);
if(0 == strncmp(classArg, "()", 2))
{
classArg = skipToArg(classArg, 2);
}
if(0 == strncmp(classArg, ".bf or.ef", 9))
{
classWords = 2;
}
symbolArg = skipToArg(classArg, 3 + (classWords - 1));
/*
** Skip particular lines/items.
*/
if(
0 != strncmp(classArg, "Label", 5) &&
0 != strncmp(symbolArg, ".bf", 3) &&
0 != strncmp(symbolArg, ".lf", 3) &&
0 != strncmp(symbolArg, ".ef", 3)
)
{
char* endOffsetArg = NULL;
unsigned offset = 0;
/*
** Convert the offset to something meaninful (size).
*/
errno = 0;
offset = strtoul(offsetArg, &endOffsetArg, 16);
if(0 == errno && endOffsetArg != offsetArg)
{
void* moved = NULL;
/*
** Increase the size of the symbol array in the section.
** Assumed symbols are unique within each section.
*/
moved = realloc(inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols, sizeof(MSDump_Symbol) * (inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbolCount + 1));
if(NULL != moved)
{
unsigned symIndex = 0;
/*
** Record symbol details.
** Assumed symbols are encountered in order for their section (size calc depends on it).
*/
symIndex = inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbolCount;
inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbolCount++;
inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols = (MSDump_Symbol*)moved;
memset(&inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex], 0, sizeof(MSDump_Symbol));
inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mOffset = offset;
/*
** We could allocate smarter here if it ever mattered.
*/
inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mName = strdup(symbolArg);
if(NULL != inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mName)
{
char* trim = NULL;
trim = (char*)skipNonWhite(inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mName);
if(NULL != trim)
{
*trim = '\0';
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Unable to duplicate symbol name.");
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Unable to grow symbol array for section.");
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Unable to convert offset to a number.");
}
}
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Unable to determine section index.");
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "No match for section prefix.");
}
}
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, inLine, "Unable to scan for section.");
}
}
return retval;
}
void dumpCleanup(MSDump_Container* inContainer)
/*
** Attempt to be nice and free up what we have allocated.
*/
{
unsigned objectLoop = 0;
unsigned sectionLoop = 0;
unsigned symbolLoop = 0;
for(objectLoop = 0; objectLoop < inContainer->mObjectCount; objectLoop++)
{
for(sectionLoop = 0; sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++)
{
for(symbolLoop = 0; symbolLoop < inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount; symbolLoop++)
{
CLEANUP(inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mName);
}
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount = 0;
CLEANUP(inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols);
CLEANUP(inContainer->mObjects[objectLoop].mSections[sectionLoop].mType);
}
inContainer->mObjects[objectLoop].mSectionCount = 0;
CLEANUP(inContainer->mObjects[objectLoop].mSections);
}
CLEANUP(inContainer->mObjects);
inContainer->mObjectCount = 0;
}
int qsortSymOffset(const void* in1, const void* in2)
/*
** qsort callback to sort the symbols by their offset.
*/
{
MSDump_Symbol* sym1 = (MSDump_Symbol*)in1;
MSDump_Symbol* sym2 = (MSDump_Symbol*)in2;
int retval = 0;
if(sym1->mOffset < sym2->mOffset)
{
retval = 1;
}
else if(sym1->mOffset > sym2->mOffset)
{
retval = -1;
}
return retval;
}
int calcContainer(Options* inOptions, MSDump_Container* inContainer)
/*
** Resposible for doing any size calculations based on the offsets known.
** After this calculation, each sections mUsed will match mSize.
** After this calculation, all symbols should know how big they are.
*/
{
int retval = 0;
unsigned objectLoop = 0;
unsigned sectionLoop = 0;
unsigned symbolLoop = 0;
/*
** Need to sort all symbols by their offsets.
*/
for(objectLoop = 0; 0 == retval && objectLoop < inContainer->mObjectCount; objectLoop++)
{
for(sectionLoop = 0; 0 == retval && sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++)
{
qsort(
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols,
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount,
sizeof(MSDump_Symbol),
qsortSymOffset
);
}
}
/*
** Need to go through all symbols and calculate their size.
*/
for(objectLoop = 0; 0 == retval && objectLoop < inContainer->mObjectCount; objectLoop++)
{
for(sectionLoop = 0; 0 == retval && sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++)
{
for(symbolLoop = 0; 0 == retval && symbolLoop < inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount; symbolLoop++)
{
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mSize =
inContainer->mObjects[objectLoop].mSections[sectionLoop].mLength -
inContainer->mObjects[objectLoop].mSections[sectionLoop].mUsed -
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mOffset;
inContainer->mObjects[objectLoop].mSections[sectionLoop].mUsed +=
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mSize;
}
}
}
return retval;
}
int reportContainer(Options* inOptions, MSDump_Container* inContainer)
/*
** Display all symbols and their data.
** We'll use a tsv format.
*/
{
int retval = 0;
unsigned objectLoop = 0;
unsigned sectionLoop = 0;
unsigned symbolLoop = 0;
int printRes = 0;
for(objectLoop = 0; 0 == retval && objectLoop < inContainer->mObjectCount; objectLoop++)
{
for(sectionLoop = 0; 0 == retval && sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++)
{
for(symbolLoop = 0; 0 == retval && symbolLoop < inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount; symbolLoop++)
{
printRes = fprintf(inOptions->mOutput, "%s\t%s\t%.8X\t%s\n",
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mName,
inContainer->mObjects[objectLoop].mSections[sectionLoop].mType,
inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mSize,
inContainer->mObjects[objectLoop].mObject
);
if(0 > printRes)
{
retval = __LINE__;
ERROR_REPORT(retval, inOptions->mOutputName, "Unable to write to file.");
}
}
}
}
return retval;
}
int dump2symdb(Options* inOptions)
/*
** Convert the input into the output, respecting the options.
** Returns 0 on success.
*/
{
int retval = 0;
char lineBuffer[0x800];
MSDump_Container container;
memset(&container, 0, sizeof(container));
/*
** Read the file line by line.
*/
while(0 == retval && NULL != fgets(lineBuffer, sizeof(lineBuffer), inOptions->mInput))
{
if(0 != container.mReadState.mSkipLines)
{
container.mReadState.mSkipLines--;
continue;
}
retval = processLine(inOptions, &container, lineBuffer);
}
/*
** Perform whatever calculations desired.
*/
if(0 == retval)
{
retval = calcContainer(inOptions, &container);
}
/*
** Output what we know.
*/
if(0 == retval)
{
retval = reportContainer(inOptions, &container);
}
/*
** Cleanup what we've done.
*/
dumpCleanup(&container);
return retval;
}
int initOptions(Options* outOptions, int inArgc, char** inArgv)
/*
** returns int 0 if successful.
*/
{
int retval = 0;
int loop = 0;
int switchLoop = 0;
int match = 0;
const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
Switch* current = NULL;
/*
** Set any defaults.
*/
memset(outOptions, 0, sizeof(Options));
outOptions->mProgramName = inArgv[0];
outOptions->mInput = stdin;
outOptions->mInputName = strdup("stdin");
outOptions->mOutput = stdout;
outOptions->mOutputName = strdup("stdout");
if(NULL == outOptions->mOutputName || NULL == outOptions->mInputName)
{
retval = __LINE__;
ERROR_REPORT(retval, "stdin/stdout", "Unable to strdup.");
}
/*
** Go through and attempt to do the right thing.
*/
for(loop = 1; loop < inArgc && 0 == retval; loop++)
{
match = 0;
current = NULL;
for(switchLoop = 0; switchLoop < switchCount && 0 == retval; switchLoop++)
{
if(0 == strcmp(gSwitches[switchLoop]->mLongName, inArgv[loop]))
{
match = __LINE__;
}
else if(0 == strcmp(gSwitches[switchLoop]->mShortName, inArgv[loop]))
{
match = __LINE__;
}
if(match)
{
if(gSwitches[switchLoop]->mHasValue)
{
/*
** Attempt to absorb next option to fullfill value.
*/
if(loop + 1 < inArgc)
{
loop++;
current = gSwitches[switchLoop];
current->mValue = inArgv[loop];
}
}
else
{
current = gSwitches[switchLoop];
}
break;
}
}
if(0 == match)
{
outOptions->mHelp = __LINE__;
retval = __LINE__;
ERROR_REPORT(retval, inArgv[loop], "Unknown command line switch.");
}
else if(NULL == current)
{
outOptions->mHelp = __LINE__;
retval = __LINE__;
ERROR_REPORT(retval, inArgv[loop], "Command line switch requires a value.");
}
else
{
/*
** Do something based on address/swtich.
*/
if(current == &gInputSwitch)
{
CLEANUP(outOptions->mInputName);
if(NULL != outOptions->mInput && stdin != outOptions->mInput)
{
fclose(outOptions->mInput);
outOptions->mInput = NULL;
}
outOptions->mInput = fopen(current->mValue, "r");
if(NULL == outOptions->mInput)
{
retval = __LINE__;
ERROR_REPORT(retval, current->mValue, "Unable to open input file.");
}
else
{
outOptions->mInputName = strdup(current->mValue);
if(NULL == outOptions->mInputName)
{
retval = __LINE__;
ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
}
}
}
else if(current == &gOutputSwitch)
{
CLEANUP(outOptions->mOutputName);
if(NULL != outOptions->mOutput && stdout != outOptions->mOutput)
{
fclose(outOptions->mOutput);
outOptions->mOutput = NULL;
}
outOptions->mOutput = fopen(current->mValue, "a");
if(NULL == outOptions->mOutput)
{
retval = __LINE__;
ERROR_REPORT(retval, current->mValue, "Unable to open output file.");
}
else
{
outOptions->mOutputName = strdup(current->mValue);
if(NULL == outOptions->mOutputName)
{
retval = __LINE__;
ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
}
}
}
else if(current == &gHelpSwitch)
{
outOptions->mHelp = __LINE__;
}
else
{
retval = __LINE__;
ERROR_REPORT(retval, current->mLongName, "No handler for command line switch.");
}
}
}
return retval;
}
void cleanOptions(Options* inOptions)
/*
** Clean up any open handles.
*/
{
CLEANUP(inOptions->mInputName);
if(NULL != inOptions->mInput && stdin != inOptions->mInput)
{
fclose(inOptions->mInput);
}
CLEANUP(inOptions->mOutputName);
if(NULL != inOptions->mOutput && stdout != inOptions->mOutput)
{
fclose(inOptions->mOutput);
}
memset(inOptions, 0, sizeof(Options));
}
void showHelp(Options* inOptions)
/*
** Show some simple help text on usage.
*/
{
int loop = 0;
const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
const char* valueText = NULL;
printf("usage:\t%s [arguments]\n", inOptions->mProgramName);
printf("\n");
printf("arguments:\n");
for(loop = 0; loop < switchCount; loop++)
{
if(gSwitches[loop]->mHasValue)
{
valueText = " <value>";
}
else
{
valueText = "";
}
printf("\t%s%s\n", gSwitches[loop]->mLongName, valueText);
printf("\t %s%s", gSwitches[loop]->mShortName, valueText);
printf(DESC_NEWLINE "%s\n\n", gSwitches[loop]->mDescription);
}
printf("This tool takes the output of \"dumpbin /symbols\" to produce a simple\n");
printf("tsv db file of symbols and their respective attributes, like size.\n");
}
int main(int inArgc, char** inArgv)
{
int retval = 0;
Options options;
retval = initOptions(&options, inArgc, inArgv);
if(options.mHelp)
{
showHelp(&options);
}
else if(0 == retval)
{
retval = dump2symdb(&options);
}
cleanOptions(&options);
return retval;
}
|
the_stack_data/192329715.c | _Bool fooBool();
_Bool fooBool() {
return 1;
}
int main() {
_Bool aBool = 1;
_Bool a = fooBool();
return 0;
} |
the_stack_data/86695.c | /*
*
* Embedded System Architecture
* Copyright (c) 2018 Packt
*
* Author: Daniele Lacamera <[email protected]>
*
* MIT License
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
extern unsigned int _stored_data;
extern unsigned int _start_data;
extern unsigned int _end_data;
extern unsigned int _start_bss;
extern unsigned int _end_bss;
extern unsigned int _end_stack;
extern unsigned int _start_heap;
static int zeroed_variable_in_bss;
static int initialized_variable_in_data = 42;
#define STACK_PAINTING
static volatile unsigned int avail_mem = 0;
static unsigned int sp;
extern void main(void);
void isr_reset(void) {
register unsigned int *src, *dst;
src = (unsigned int *) &_stored_data;
dst = (unsigned int *) &_start_data;
while (dst < (unsigned int *)&_end_data) {
*dst = *src;
dst++;
src++;
}
/* Initialize the BSS section to 0 */
dst = &_start_bss;
while (dst < (unsigned int *)&_end_bss) {
*dst = 0U;
dst++;
}
/* Paint the stack. */
avail_mem = &_end_stack - &_start_heap;
#ifdef STACK_PAINTING
{
asm volatile("mrs %0, msp" : "=r"(sp));
dst = ((unsigned int *)(&_end_stack)) - (8192 / sizeof(unsigned int)); ;
while ((unsigned int)dst < sp) {
*dst = 0xDEADC0DE;
dst++;
}
}
#endif
/* Run the program! */
main();
}
void isr_fault(void)
{
/* Panic. */
while(1) ;;
}
void isr_memfault(void)
{
/* Panic. */
while(1) ;;
}
void isr_busfault(void)
{
/* Panic. */
while(1) ;;
}
void isr_usagefault(void)
{
/* Panic. */
while(1) ;;
}
void isr_empty(void)
{
}
__attribute__ ((section(".isr_vector")))
void (* const IV[])(void) =
{
(void (*)(void))(&_end_stack),
isr_reset, // Reset
isr_fault, // NMI
isr_fault, // HardFault
isr_memfault, // MemFault
isr_busfault, // BusFault
isr_usagefault, // UsageFault
0, 0, 0, 0, // 4x reserved
isr_empty, // SVC
isr_empty, // DebugMonitor
0, // reserved
isr_empty, // PendSV
isr_empty, // SysTick
isr_empty, // NVIC_WWDG_IRQ 0
isr_empty, // PVD_IRQ 1
isr_empty, // TAMP_STAMP_IRQ 2
isr_empty, // RTC_WKUP_IRQ 3
isr_empty, // FLASH_IRQ 4
isr_empty, // RCC_IRQ 5
isr_empty, // EXTI0_IRQ 6
isr_empty, // EXTI1_IRQ 7
isr_empty, // EXTI2_IRQ 8
isr_empty, // EXTI3_IRQ 9
isr_empty, // EXTI4_IRQ 10
isr_empty, // DMA1_STREAM0_IRQ 11
isr_empty, // DMA1_STREAM1_IRQ 12
isr_empty, // DMA1_STREAM2_IRQ 13
isr_empty, // DMA1_STREAM3_IRQ 14
isr_empty, // DMA1_STREAM4_IRQ 15
isr_empty, // DMA1_STREAM5_IRQ 16
isr_empty, // DMA1_STREAM6_IRQ 17
isr_empty, // ADC_IRQ 18
isr_empty, // CAN1_TX_IRQ 19
isr_empty, // CAN1_RX0_IRQ 20
isr_empty, // CAN1_RX1_IRQ 21
isr_empty, // CAN1_SCE_IRQ 22
isr_empty, // EXTI9_5_IRQ 23
isr_empty, // TIM1_BRK_TIM9_IRQ 24
isr_empty, // TIM1_UP_TIM10_IRQ 25
isr_empty, // TIM1_TRG_COM_TIM11_IRQ 26
isr_empty, // TIM1_CC_IRQ 27
isr_empty, // TIM2_IRQ 28
isr_empty, // TIM3_IRQ 29
isr_empty, // TIM4_IRQ 30
isr_empty, // I2C1_EV_IRQ 31
isr_empty, // I2C1_ER_IRQ 32
isr_empty, // I2C2_EV_IRQ 33
isr_empty, // I2C2_ER_IRQ 34
isr_empty, // SPI1_IRQ 35
isr_empty, // SPI2_IRQ 36
isr_empty, // USART1_IRQ 37
isr_empty, // USART2_IRQ 38
isr_empty, // USART3_IRQ 39
isr_empty, // EXTI15_10_IRQ 40
isr_empty, // RTC_ALARM_IRQ 41
isr_empty, // USB_FS_WKUP_IRQ 42
isr_empty, // TIM8_BRK_TIM12_IRQ 43
isr_empty, // TIM8_UP_TIM13_IRQ 44
isr_empty, // TIM8_TRG_COM_TIM14_IRQ 45
isr_empty, // TIM8_CC_IRQ 46
isr_empty, // DMA1_STREAM7_IRQ 47
};
|
the_stack_data/165765176.c | #include <stdio.h>
typedef struct node {
int val;
struct node *prev;
struct node *next;
}node;
typedef struct list {
node *head;
node *tail;
}list;
int main() {
node a = {1,0,0};
node b = {2,0,0};
node c = {3,0,0};
node d = {4,0,0};
list str = { 0 , 0 };
str.head = &a;
str.tail = &d;
a.prev = NULL;
a.next = &b;
b.prev = &a;
b.next = &c;
c.prev = &b;
c.next = &d;
d.prev = &c;
d.next = NULL;
printf("%d",str.head->next->next->val);
return 0;
}
|
the_stack_data/126704070.c | /* -*- C -*-
* Copyright (c) 2003-2006 Motoyuki Kasahara
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <sys/types.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#ifdef HAVE_ICONV_H
#include <iconv.h>
#endif
#if defined(HAVE_LIBCHARSET_H)
#include <libcharset.h>
#elif defined(HAVE_LANGINFO_H)
#include <langinfo.h>
#endif
/*
* Convert `string' from EUC-JP to the current locale encoding, and
* then write it to `stream'.
*/
int
fputs_eucjp_to_locale(const char *string, FILE *stream)
{
#if defined(HAVE_ICONV_OPEN)
size_t string_length;
const char *locale_encoding;
char *buffer = NULL;
size_t buffer_size;
iconv_t cd = (iconv_t)-1;
const char *in_p;
char *out_p;
size_t in_left;
size_t out_left;
int fputs_result;
string_length = strlen(string);
#if defined(HAVE_LOCALE_CHARSET)
locale_encoding = locale_charset();
#elif defined(HAVE_NL_LANGINFO) && defined(CODESET)
locale_encoding = nl_langinfo(CODESET);
#else
locale_encoding = NULL;
#endif
if (locale_encoding == NULL)
goto failed;
cd = iconv_open(locale_encoding, "eucJP");
if (cd == (iconv_t)-1)
cd = iconv_open(locale_encoding, "EUC-JP");
if (cd == (iconv_t)-1)
goto failed;
buffer_size = (string_length + 1) * 2;
for (;;) {
buffer = malloc(buffer_size);
if (buffer == NULL)
goto failed;
in_p = string;
in_left = string_length + 1;
out_p = buffer;
out_left = buffer_size;
if (iconv(cd, &in_p, &in_left, &out_p, &out_left) != -1)
break;
if (errno == E2BIG) {
/*
* Reset initial state.
* To avoid a bug of iconv() on Solaris 2.6, we set `in_left',
* `out_p' and `out_left' to non-NULL values.
*/
in_left = 0;
out_p = buffer;
out_left = 0;
iconv(cd, NULL, &in_left, &out_p, &out_left);
free(buffer);
buffer = NULL;
buffer_size += string_length + 1;
continue;
} else {
goto failed;
}
}
iconv_close(cd);
fputs_result = fputs(buffer, stream);
free(buffer);
return fputs_result;
/*
* An error occurs...
*/
failed:
if (cd != (iconv_t)-1)
iconv_close(cd);
if (buffer != NULL)
free(buffer);
return fputs(string, stream);
#else /* not HAVE_ICONV_OPEN */
return fputs(string, stream);
#endif /* not HAVE_ICONV_OPEN */
}
/*
* Convert `string' from EUC-JP to the current locale encoding, and
* then write it and a newline to `stdout'.
*/
int
puts_eucjp_to_locale(const char *string)
{
if (fputs_eucjp_to_locale(string, stdout) == EOF)
return EOF;
if (fputs_eucjp_to_locale("\n", stdout) == EOF)
return EOF;
return 0;
}
|
the_stack_data/661169.c | #include <stdlib.h>
/* interopse with myftype_1 */
typedef struct {
float *ptr;
int *ptr2;
} myctype_t;
extern void abort(void);
void types_test(void);
/* declared in the fortran module */
extern myctype_t myVar;
int main(int argc, char **argv)
{
myctype_t *cptr;
asm("":"=r"(cptr):"0"(&myVar));
cptr->ptr = (float *)(size_t) (void *)1;
cptr->ptr2 = (int *)(size_t) (void *)2;
types_test();
if(cptr->ptr != (float *)(size_t) (void *)2)
abort();
if(cptr->ptr2 != (int *)(size_t) (void *)2)
abort();
myVar.ptr2 = (int *)(size_t) (void *)3;
types_test();
if(myVar.ptr != (float *)(size_t) (void *)3)
abort();
if(myVar.ptr2 != (int *)(size_t) (void *)3)
abort();
return 0;
}
|
the_stack_data/41495.c | /**
* ppjC je programski jezik podskup jezika C definiran u dokumentu
* https://github.com/fer-ppj/ppj-labosi/raw/master/upute/ppj-labos-upute.pdf
*
* ova skripta poziva ppjC kompajler (za sada samo analizator) pritiskom
* na tipku [Ctrl+S], [Shift+Enter] ili [Alt+3] i prikazuje rezultat analize.
*
* ne garantiram tocnost leksera, sintaksnog niti semantickog analizatora koji
* se ovdje pokrece.
*
* URL skripte prati verzije izvornog programa, tako da je moguca razmjena
* izvornih programa u timu putem URL-ova.
*/
int printf(const char format[]) {
/* i wish i could printf */
return 0;
}
int main(void) {
//const char[33] = { 'a', '\0' };
int printf( const char format[] );
//const char[10] = "abc";
return printf("hello world!\n");
}
|
the_stack_data/149124.c |
#include "stdio.h"
#include <stdarg.h>
#include <string.h>
int __android_log_print(int prio, const char *tag, const char *fmt, ...)
{
va_list ap;
char buf[256];
va_start(ap, fmt);
if(strncmp(fmt, "This application", 15)==0){
return 0;
}
vsnprintf(buf, 256, fmt, ap);
va_end(ap);
return printf(buf);
}
|
the_stack_data/111077452.c | /*
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifdef WEBRTC_ARCH_ARM_FAMILY
#include <arm_neon.h>
#include <stdlib.h>
#include "checks.h"
#include "signal_processing_library.h"
// Maximum absolute value of word16 vector. C version for generic platforms.
int16_t WebRtcSpl_MaxAbsValueW16Neon(const int16_t* vector, size_t length) {
int absolute = 0, maximum = 0;
RTC_DCHECK_GT(length, 0);
const int16_t* p_start = vector;
size_t rest = length & 7;
const int16_t* p_end = vector + length - rest;
int16x8_t v;
uint16x8_t max_qv;
max_qv = vdupq_n_u16(0);
while (p_start < p_end) {
v = vld1q_s16(p_start);
// Note vabs doesn't change the value of -32768.
v = vabsq_s16(v);
// Use u16 so we don't lose the value -32768.
max_qv = vmaxq_u16(max_qv, vreinterpretq_u16_s16(v));
p_start += 8;
}
#ifdef WEBRTC_ARCH_ARM64
maximum = (int)vmaxvq_u16(max_qv);
#else
uint16x4_t max_dv;
max_dv = vmax_u16(vget_low_u16(max_qv), vget_high_u16(max_qv));
max_dv = vpmax_u16(max_dv, max_dv);
max_dv = vpmax_u16(max_dv, max_dv);
maximum = (int)vget_lane_u16(max_dv, 0);
#endif
p_end = vector + length;
while (p_start < p_end) {
absolute = abs((int)(*p_start));
if (absolute > maximum) {
maximum = absolute;
}
p_start++;
}
// Guard the case for abs(-32768).
if (maximum > WEBRTC_SPL_WORD16_MAX) {
maximum = WEBRTC_SPL_WORD16_MAX;
}
return (int16_t)maximum;
}
// Maximum absolute value of word32 vector. NEON intrinsics version for
// ARM 32-bit/64-bit platforms.
int32_t WebRtcSpl_MaxAbsValueW32Neon(const int32_t* vector, size_t length) {
// Use uint32_t for the local variables, to accommodate the return value
// of abs(0x80000000), which is 0x80000000.
uint32_t absolute = 0, maximum = 0;
size_t i = 0;
size_t residual = length & 0x7;
RTC_DCHECK_GT(length, 0);
const int32_t* p_start = vector;
uint32x4_t max32x4_0 = vdupq_n_u32(0);
uint32x4_t max32x4_1 = vdupq_n_u32(0);
// First part, unroll the loop 8 times.
for (i = 0; i < length - residual; i += 8) {
int32x4_t in32x4_0 = vld1q_s32(p_start);
p_start += 4;
int32x4_t in32x4_1 = vld1q_s32(p_start);
p_start += 4;
in32x4_0 = vabsq_s32(in32x4_0);
in32x4_1 = vabsq_s32(in32x4_1);
// vabs doesn't change the value of 0x80000000.
// Use u32 so we don't lose the value 0x80000000.
max32x4_0 = vmaxq_u32(max32x4_0, vreinterpretq_u32_s32(in32x4_0));
max32x4_1 = vmaxq_u32(max32x4_1, vreinterpretq_u32_s32(in32x4_1));
}
uint32x4_t max32x4 = vmaxq_u32(max32x4_0, max32x4_1);
#if defined(WEBRTC_ARCH_ARM64)
maximum = vmaxvq_u32(max32x4);
#else
uint32x2_t max32x2 = vmax_u32(vget_low_u32(max32x4), vget_high_u32(max32x4));
max32x2 = vpmax_u32(max32x2, max32x2);
maximum = vget_lane_u32(max32x2, 0);
#endif
// Second part, do the remaining iterations (if any).
for (i = residual; i > 0; i--) {
absolute = abs((int)(*p_start));
if (absolute > maximum) {
maximum = absolute;
}
p_start++;
}
// Guard against the case for 0x80000000.
maximum = WEBRTC_SPL_MIN(maximum, WEBRTC_SPL_WORD32_MAX);
return (int32_t)maximum;
}
// Maximum value of word16 vector. NEON intrinsics version for
// ARM 32-bit/64-bit platforms.
int16_t WebRtcSpl_MaxValueW16Neon(const int16_t* vector, size_t length) {
int16_t maximum = WEBRTC_SPL_WORD16_MIN;
size_t i = 0;
size_t residual = length & 0x7;
RTC_DCHECK_GT(length, 0);
const int16_t* p_start = vector;
int16x8_t max16x8 = vdupq_n_s16(WEBRTC_SPL_WORD16_MIN);
// First part, unroll the loop 8 times.
for (i = 0; i < length - residual; i += 8) {
int16x8_t in16x8 = vld1q_s16(p_start);
max16x8 = vmaxq_s16(max16x8, in16x8);
p_start += 8;
}
#if defined(WEBRTC_ARCH_ARM64)
maximum = vmaxvq_s16(max16x8);
#else
int16x4_t max16x4 = vmax_s16(vget_low_s16(max16x8), vget_high_s16(max16x8));
max16x4 = vpmax_s16(max16x4, max16x4);
max16x4 = vpmax_s16(max16x4, max16x4);
maximum = vget_lane_s16(max16x4, 0);
#endif
// Second part, do the remaining iterations (if any).
for (i = residual; i > 0; i--) {
if (*p_start > maximum)
maximum = *p_start;
p_start++;
}
return maximum;
}
// Maximum value of word32 vector. NEON intrinsics version for
// ARM 32-bit/64-bit platforms.
int32_t WebRtcSpl_MaxValueW32Neon(const int32_t* vector, size_t length) {
int32_t maximum = WEBRTC_SPL_WORD32_MIN;
size_t i = 0;
size_t residual = length & 0x7;
RTC_DCHECK_GT(length, 0);
const int32_t* p_start = vector;
int32x4_t max32x4_0 = vdupq_n_s32(WEBRTC_SPL_WORD32_MIN);
int32x4_t max32x4_1 = vdupq_n_s32(WEBRTC_SPL_WORD32_MIN);
// First part, unroll the loop 8 times.
for (i = 0; i < length - residual; i += 8) {
int32x4_t in32x4_0 = vld1q_s32(p_start);
p_start += 4;
int32x4_t in32x4_1 = vld1q_s32(p_start);
p_start += 4;
max32x4_0 = vmaxq_s32(max32x4_0, in32x4_0);
max32x4_1 = vmaxq_s32(max32x4_1, in32x4_1);
}
int32x4_t max32x4 = vmaxq_s32(max32x4_0, max32x4_1);
#if defined(WEBRTC_ARCH_ARM64)
maximum = vmaxvq_s32(max32x4);
#else
int32x2_t max32x2 = vmax_s32(vget_low_s32(max32x4), vget_high_s32(max32x4));
max32x2 = vpmax_s32(max32x2, max32x2);
maximum = vget_lane_s32(max32x2, 0);
#endif
// Second part, do the remaining iterations (if any).
for (i = residual; i > 0; i--) {
if (*p_start > maximum)
maximum = *p_start;
p_start++;
}
return maximum;
}
// Minimum value of word16 vector. NEON intrinsics version for
// ARM 32-bit/64-bit platforms.
int16_t WebRtcSpl_MinValueW16Neon(const int16_t* vector, size_t length) {
int16_t minimum = WEBRTC_SPL_WORD16_MAX;
size_t i = 0;
size_t residual = length & 0x7;
RTC_DCHECK_GT(length, 0);
const int16_t* p_start = vector;
int16x8_t min16x8 = vdupq_n_s16(WEBRTC_SPL_WORD16_MAX);
// First part, unroll the loop 8 times.
for (i = 0; i < length - residual; i += 8) {
int16x8_t in16x8 = vld1q_s16(p_start);
min16x8 = vminq_s16(min16x8, in16x8);
p_start += 8;
}
#if defined(WEBRTC_ARCH_ARM64)
minimum = vminvq_s16(min16x8);
#else
int16x4_t min16x4 = vmin_s16(vget_low_s16(min16x8), vget_high_s16(min16x8));
min16x4 = vpmin_s16(min16x4, min16x4);
min16x4 = vpmin_s16(min16x4, min16x4);
minimum = vget_lane_s16(min16x4, 0);
#endif
// Second part, do the remaining iterations (if any).
for (i = residual; i > 0; i--) {
if (*p_start < minimum)
minimum = *p_start;
p_start++;
}
return minimum;
}
// Minimum value of word32 vector. NEON intrinsics version for
// ARM 32-bit/64-bit platforms.
int32_t WebRtcSpl_MinValueW32Neon(const int32_t* vector, size_t length) {
int32_t minimum = WEBRTC_SPL_WORD32_MAX;
size_t i = 0;
size_t residual = length & 0x7;
RTC_DCHECK_GT(length, 0);
const int32_t* p_start = vector;
int32x4_t min32x4_0 = vdupq_n_s32(WEBRTC_SPL_WORD32_MAX);
int32x4_t min32x4_1 = vdupq_n_s32(WEBRTC_SPL_WORD32_MAX);
// First part, unroll the loop 8 times.
for (i = 0; i < length - residual; i += 8) {
int32x4_t in32x4_0 = vld1q_s32(p_start);
p_start += 4;
int32x4_t in32x4_1 = vld1q_s32(p_start);
p_start += 4;
min32x4_0 = vminq_s32(min32x4_0, in32x4_0);
min32x4_1 = vminq_s32(min32x4_1, in32x4_1);
}
int32x4_t min32x4 = vminq_s32(min32x4_0, min32x4_1);
#if defined(WEBRTC_ARCH_ARM64)
minimum = vminvq_s32(min32x4);
#else
int32x2_t min32x2 = vmin_s32(vget_low_s32(min32x4), vget_high_s32(min32x4));
min32x2 = vpmin_s32(min32x2, min32x2);
minimum = vget_lane_s32(min32x2, 0);
#endif
// Second part, do the remaining iterations (if any).
for (i = residual; i > 0; i--) {
if (*p_start < minimum)
minimum = *p_start;
p_start++;
}
return minimum;
}
#endif
|
the_stack_data/9512221.c | /******************************************************************************
@file StateOS: oscore.c
@author Rajmund Szymanski
@date 16.07.2018
@brief StateOS port file for ARM Cotrex-M uC.
******************************************************************************
Copyright (c) 2018 Rajmund Szymanski. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
******************************************************************************/
#if defined(__ICCARM__)
#include "oskernel.h"
/* -------------------------------------------------------------------------- */
#if __CORTEX_M < 3
__attribute__((naked))
void PendSV_Handler( void )
{
__ASM volatile
(
" mrs r0, PSP \n"
" mov r3, lr \n"
" lsrs r3, r3, # 3 \n"
" bcs 1f \n"
" mov r0, sp \n"
" sub sp, # 36 \n"
"1: subs r0, # 36 \n"
" stm r0!, { r4 - r7 } \n"
" mov r3, r8 \n"
" mov r4, r9 \n"
" mov r5, r10 \n"
" mov r6, r11 \n"
" mov r7, lr \n"
" stm r0!, { r3 - r7 } \n"
" subs r0, # 36 \n"
" bl %c[core_tsk_handler] \n"
" adds r0, # 16 \n"
" ldm r0!, { r3 - r7 } \n"
" mov r8, r3 \n"
" mov r9, r4 \n"
" mov r10, r5 \n"
" mov r11, r6 \n"
" mov lr, r7 \n"
" subs r0, # 36 \n"
" ldm r0!, { r4 - r7 } \n"
" adds r0, # 20 \n"
" mov r3, lr \n"
" lsrs r3, r3, # 3 \n"
" bcs 2f \n"
" mov sp, r0 \n"
" bx lr \n"
"2: msr PSP, r0 \n"
" bx lr \n"
:: [core_tsk_handler] "i" (core_tsk_handler)
: "memory"
);
}
#endif//__CORTEX_M
/* -------------------------------------------------------------------------- */
#if __CORTEX_M >= 3
__attribute__((naked))
void PendSV_Handler( void )
{
__ASM volatile
(
" tst lr, # 4 \n"
" itee ne \n"
" mrsne r0, PSP \n"
" moveq r0, sp \n"
#if __FPU_USED
" subeq sp, # 100 \n"
" tst lr, # 16 \n"
" it eq \n"
"vstmdbeq r0!, { s16 - s31 } \n"
#else
" subeq sp, # 36 \n"
#endif
" stmdb r0!, { r4 - r11, lr } \n"
" bl %c[core_tsk_handler] \n"
" ldmia r0!, { r4 - r11, lr } \n"
#if __FPU_USED
" tst lr, # 16 \n"
" it eq \n"
"vldmiaeq r0!, { s16 - s31 } \n"
#endif
" tst lr, # 4 \n"
" ite ne \n"
" msrne PSP, r0 \n"
" moveq sp, r0 \n"
" bx lr \n"
:: [core_tsk_handler] "i" (core_tsk_handler)
: "memory"
);
}
#endif//__CORTEX_M
/* -------------------------------------------------------------------------- */
__attribute__((naked))
void core_tsk_flip( void *sp )
{
__ASM volatile
(
" mov sp, %[sp] \n"
" b %c[core_tsk_loop] \n"
:: [sp] "r" (sp),
[core_tsk_loop] "i" (core_tsk_loop)
: "memory"
);
for(;;);
}
/* -------------------------------------------------------------------------- */
#endif // __ICCARM__
|
the_stack_data/7756.c | /*
nb_n.c : Clasificador Naive Bayes usando la aproximacion de funciones normales para features continuos
Formato de datos: c4.5
La clase a predecir tiene que ser un numero comenzando de 0: por ejemplo, para 3 clases, las clases deben ser 0,1,2
PMG - Ultima revision: 20/06/2001
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#define LOW 1.e-14 /*Minimo valor posible para una probabilidad*/
#define PI 3.141592653
int N_IN; /*Total numbre of inputs*/
int N_Class; /*Total number of classes (outputs)*/
int PTOT; /* cantidad TOTAL de patrones en el archivo .data */
int PR; /* cantidad de patrones de ENTRENAMIENTO */
int PTEST; /* cantidad de patrones de TEST (archivo .test) */
/* cantidad de patrones de VALIDACION: PTOT - PR*/
int SEED; /* semilla para la funcion rand(). Los posibles valores son:*/
/* SEED: -1: No mezclar los patrones: usar los primeros PR para entrenar
y el resto para validar.Toma la semilla del rand con el reloj.
0: Seleccionar semilla con el reloj, y mezclar los patrones.
>0: Usa el numero leido como semilla, y mezcla los patrones. */
int CONTROL; /* nivel de verbosity: 0 -> solo resumen, 1 -> 0 + pesos, 2 -> 1 + datos*/
int N_TOTAL; /*Numero de patrones a usar durante el entrenamiento*/
int NBINS;
/*matrices globales DECLARAR ACA LAS MATRICES NECESARIAS */
double **data; /* train data */
double **test; /* test data */
int *pred; /* clases predichas */
int *ccc; //ccc contiene la Cantidad de Cada Clase en los datos
double *minVal;
double *maxVal;
double ***bin;
int *seq; /* sequencia de presentacion de los patrones*/
/*variables globales auxiliares*/
char filepat[100];
/*bandera de error*/
int error;
/* -------------------------------------------------------------------------- */
/*define_matrix: reserva espacio en memoria para todas las matrices declaradas.
Todas las dimensiones son leidas del archivo .nb en la funcion arquitec() */
/* -------------------------------------------------------------------------- */
int define_matrix(){
int i,max,j;
if(PTOT>PTEST) max=PTOT;
else max=PTEST;
seq =(int *)calloc(max,sizeof(int));
pred=(int *)calloc(max,sizeof(int));
if(seq==NULL||pred==NULL) return 1;
data=(double **)calloc(PTOT,sizeof(double *));
if(PTEST) test=(double **)calloc(PTEST,sizeof(double *));
if(data==NULL||(PTEST&&test==NULL)) return 1;
for(i=0;i<PTOT;i++){
data[i]=(double *)calloc(N_IN+1,sizeof(double));
if(data[i]==NULL) return 1;
}
for(i=0;i<PTEST;i++){
test[i]=(double *)calloc(N_IN+1,sizeof(double));
if(test[i]==NULL) return 1;
}
/*ALLOCAR ESPACIO PARA LAS MATRICES DEL ALGORITMO*/
ccc=(int *)calloc(N_Class,sizeof(int));
if(ccc==NULL)
return 1;
minVal=(double*) calloc (N_IN, sizeof(double));
if(minVal==NULL)
return 1;
maxVal=(double*) calloc (N_IN, sizeof(double));
if(maxVal==NULL)
return 1;
bin = (double ***)calloc(N_Class, sizeof(double**));
for(i = 0;i < N_Class;i++) {
bin[i] = (double**)calloc(N_IN, sizeof(double*));
if (bin[i] == NULL)
return 1;
for(j = 0;j < N_IN;j++) {
bin[i][j] = (double*)calloc(NBINS, sizeof(double));
if (bin[i][j] == NULL)
return 1;
}
}
return 0;
}
/* ---------------------------------------------------------------------------------- */
/*arquitec: Lee el archivo .nb e inicializa el algoritmo en funcion de los valores leidos
filename es el nombre del archivo .nb (sin la extension) */
/* ---------------------------------------------------------------------------------- */
int arquitec(char *filename){
FILE *b;
time_t t;
/*Paso 1:leer el archivo con la configuracion*/
sprintf(filepat,"%s.nb",filename);
b=fopen(filepat,"r");
error=(b==NULL);
if(error){
printf("Error al abrir el archivo de parametros\n");
return 1;
}
/* Dimensiones */
fscanf(b,"%d",&N_IN);
fscanf(b,"%d",&N_Class);
/* Archivo de patrones: datos para train y para validacion */
fscanf(b,"%d",&PTOT);
fscanf(b,"%d",&PR);
fscanf(b,"%d",&PTEST);
/* Semilla para la funcion rand()*/
fscanf(b,"%d",&SEED);
/* Nivel de verbosity*/
fscanf(b,"%d",&CONTROL);
fscanf(b,"%d",&NBINS);
fclose(b);
/*Paso 2: Definir matrices para datos y parametros (e inicializarlos*/
error=define_matrix();
if(error){
printf("Error en la definicion de matrices\n");
return 1;
}
/* Chequear semilla para la funcion rand() */
if(SEED==0) SEED=time(&t);
/*Imprimir control por pantalla*/
printf("\nNaive Bayes con distribuciones normales:\nCantidad de entradas:%d",N_IN);
printf("\nCantidad de clases:%d",N_Class);
printf("\nArchivo de patrones: %s",filename);
printf("\nCantidad total de patrones: %d",PTOT);
printf("\nCantidad de patrones de entrenamiento: %d",PR);
printf("\nCantidad de patrones de validacion: %d",PTOT-PR);
printf("\nCantidad de patrones de test: %d",PTEST);
printf("\nSemilla para la funcion rand(): %d",SEED);
printf("\nCantidad de bins: %d",NBINS);
return 0;
}
/* -------------------------------------------------------------------------------------- */
/*read_data: lee los datos de los archivos de entrenamiento(.data) y test(.test)
filename es el nombre de los archivos (sin extension)
La cantidad de datos y la estructura de los archivos fue leida en la funcion arquitec()
Los registros en el archivo pueden estar separados por blancos ( o tab ) o por comas */
/* -------------------------------------------------------------------------------------- */
int read_data(char *filename){
FILE *fpat;
double valor;
int i,k,separador;
sprintf(filepat,"%s.data",filename);
fpat=fopen(filepat,"r");
error=(fpat==NULL);
if(error){
printf("Error al abrir el archivo de datos\n");
return 1;
}
if(CONTROL>1) printf("\n\nDatos de entrenamiento:");
for(k=0;k<PTOT;k++){
if(CONTROL>1) printf("\nP%d:\t",k);
for(i=0;i<N_IN+1;i++){
fscanf(fpat,"%lf",&valor);
data[k][i]=valor;
if(CONTROL>1) printf("%lf\t",data[k][i]);
separador=getc(fpat);
if(separador!=',') ungetc(separador,fpat);
}
}
fclose(fpat);
if(!PTEST) return 0;
sprintf(filepat,"%s.test",filename);
fpat=fopen(filepat,"r");
error=(fpat==NULL);
if(error){
printf("Error al abrir el archivo de test\n");
return 1;
}
if(CONTROL>1) printf("\n\nDatos de test:");
for(k=0;k<PTEST;k++){
if(CONTROL>1) printf("\nP%d:\t",k);
for(i=0;i<N_IN+1;i++){
fscanf(fpat,"%lf",&valor);
test[k][i]=valor;
if(CONTROL>1) printf("%lf\t",test[k][i]);
separador=getc(fpat);
if(separador!=',') ungetc(separador,fpat);
}
}
fclose(fpat);
return 0;
}
/* ------------------------------------------------------------ */
/* shuffle: mezcla el vector seq al azar.
El vector seq es un indice para acceder a los patrones.
Los patrones mezclados van desde seq[0] hasta seq[hasta-1]
Esto permite separar la parte de validacion de la de train */
/* ------------------------------------------------------------ */
void shuffle(int hasta){
double x;
int tmp;
int top,select;
top=hasta-1;
while (top > 0) {
x = (double)rand();
x /= RAND_MAX;
x *= (top+1);
select = (int)x;
tmp = seq[top];
seq[top] = seq[select];
seq[select] = tmp;
top --;
}
if(CONTROL>3) {printf("End shuffle\n");fflush(NULL);}
}
/* ------------------------------------------------------------------- */
/*Prob:Calcula la probabilidad de obtener el valor x para el input feature y la clase clase
Aproxima las probabilidades por distribuciones normales */
/* ------------------------------------------------------------------- */
double prob(double x,int feature,int clase) {
double width,init,end;
int i,b=0;
width = (maxVal[feature] - minVal[feature]) / NBINS;
for (i=0;i<NBINS;i++){
init = minVal[feature] + (i*width);
end = init + width;
if (x <= end && x >= init) b = i;
}
//~ printf("%.2f %.2f\n", minVal[feature], maxVal[feature]);
//~ printf("%.2f %d %d %d %.2f\n", x, clase, feature, b, bin[clase][feature][b]);
return bin [clase][feature][b];
}
/* ------------------------------------------------------------------------------ */
/*output: calcula la probabilidad de cada clase dado un vector de entrada *input
usa el log(p(x)) (sumado)
devuelve la de mayor probabilidad */
/* ------------------------------------------------------------------------------ */
int output(double *input){
double prob_de_clase;
double max_prob=-1e40;
int i,k,clase_MAP;
for(k=0;k<N_Class;k++) {
prob_de_clase = 0.;
/*calcula la probabilidad de cada feature individual dada la clase y la acumula*/
for(i=0;i<N_IN;i++){
prob_de_clase += log(prob(input[i],i,k));
}
/*agrega la probabilidad a priori de la clase*/
prob_de_clase += log((double)ccc[k]/(double)N_TOTAL);
/*guarda la clase con prob maxima*/
if (prob_de_clase>=max_prob){
max_prob=prob_de_clase;
clase_MAP=k;
}
}
return clase_MAP;
}
/* ------------------------------------------------------------------------------ */
/*propagar: calcula las clases predichas para un conjunto de datos
la matriz S tiene que tener el formato adecuado ( definido en arquitec() )
pat_ini y pat_fin son los extremos a tomar en la matriz
usar_seq define si se accede a los datos directamente o a travez del indice seq
los resultados (las propagaciones) se guardan en la matriz seq */
/* ------------------------------------------------------------------------------ */
double propagar(double **S,int pat_ini,int pat_fin,int usar_seq){
double mse=0.0;
int nu;
int patron;
for (patron=pat_ini; patron < pat_fin; patron ++) {
/*nu tiene el numero del patron que se va a presentar*/
if(usar_seq) nu = seq[patron];
else nu = patron;
/*clase MAP para el patron nu*/
pred[nu]=output(S[nu]);
/*actualizar error*/
if(S[nu][N_IN]!=(double)pred[nu]) mse+=1.;
}
mse /= ( (double)(pat_fin-pat_ini));
if(CONTROL>3) {printf("End prop\n");fflush(NULL);}
return mse;
}
/* --------------------------------------------------------------------------------------- */
/*train: ajusta los parametros del algoritmo a los datos de entrenamiento
guarda los parametros en un archivo de control
calcula porcentaje de error en ajuste y test */
/* --------------------------------------------------------------------------------------- */
int train(char *filename){
int i,j,k,feature,clase,b;
double sigma,me,x,width,aux;
double train_error,valid_error,test_error;
FILE *salida,*fpredic;
/*Asigno todos los patrones del .data como entrenamiento porque este metodo no requiere validacion*/
N_TOTAL=PR;
/*N_TOTAL=PR; si hay validacion*/
for(k=0;k<PTOT;k++) seq[k]=k; /* inicializacion del indice de acceso a los datos */
/*efectuar shuffle inicial de los datos de entrenamiento si SEED != -1 (y hay validacion)*/
if(SEED>-1 && N_TOTAL<PTOT){
srand((unsigned)SEED);
shuffle(PTOT);
}
// Completo el arreglo ccc
memset(ccc, 0, sizeof(int)*N_Class);
for (i=0;i<N_TOTAL;i++){
clase = data[seq[i]][N_IN];
ccc[clase] ++;
}
//Inicializo minimo y maximo
for (i=0;i<N_IN;i++){
minVal[i] = 1000000.999;
maxVal[i] = -1000000.999;
}
//Encuentro min y max
for (i = 0;i < N_TOTAL;i++){
for (k = 0; k<N_IN;k++){
aux = data[seq[i]][k];
if(aux < minVal[k])
minVal[k] = aux;
else if(aux > maxVal[k])
maxVal[k] = aux;
}
}
for (j=0 ; j<N_IN ; j++) {
for (k=0; k< N_TOTAL ; k++) {
x = data[seq[k]][j];
clase = data[seq[k]][N_IN];
width = (maxVal[j] - minVal[j]) / NBINS;
for (i=0;i<NBINS;i++){
if (minVal[j] + (i)*width <= x)
b = i;
}
bin[clase][j][b]++;
}
}
for (j=0 ; j<N_IN ; j++) {
for (k=0; k< N_Class ; k++) {
for (i = 0; i<NBINS; i++){
bin[k][j][i] ++;
bin[k][j][i] /= ccc[k] + NBINS;
}
}
}
/*calcular error de entrenamiento*/
train_error=propagar(data,0,PR,1);
/*calcular error de validacion; si no hay, usar mse_train*/
if(PR==PTOT) valid_error=train_error;
else valid_error=propagar(data,PR,PTOT,1);
/*calcular error de test (si hay)*/
if (PTEST>0) test_error =propagar(test,0,PTEST,0);
else test_error =0.;
/*mostrar errores*/
printf("\nFin del entrenamiento.\n\n");
printf("Errores:\nEntrenamiento:%f%%\n",train_error*100.);
printf("Validacion:%f%%\nTest:%f%%\n",valid_error*100.,test_error*100.);
if(CONTROL) fflush(NULL);
/* archivo de predicciones */
sprintf(filepat,"%s.predic",filename);
fpredic=fopen(filepat,"w");
error=(fpredic==NULL);
if(error){
printf("Error al abrir archivo para guardar predicciones\n");
return 1;
}
for(k=0; k < PTEST ; k++){
for( i = 0 ;i< N_IN;i++) fprintf(fpredic,"%f\t",test[k][i]);
fprintf(fpredic,"%d\n",pred[k]);
}
fclose(fpredic);
return 0;
}
/* ----------------------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------------------- */
int main(int argc, char **argv){
if(argc!=2){
printf("Modo de uso: nb <filename>\ndonde filename es el nombre del archivo (sin extension)\n");
return 0;
}
/* defino la estructura*/
error=arquitec(argv[1]);
if(error){
printf("Error en la definicion de parametros\n");
return 1;
}
/* leo los datos */
error=read_data(argv[1]);
if(error){
printf("Error en la lectura de datos\n");
return 1;
}
/* ajusto los parametros y calcula errores en ajuste y test*/
error=train(argv[1]);
if(error){
printf("Error en el ajuste\n");
return 1;
}
return 0;
}
/* ----------------------------------------------------------------------------------------------------- */
|
the_stack_data/3263246.c | // We need to test that a file compiled with a reference to another directory (e.g. "path/foo.c")
// will be place back into that directory as "path/rose_foo.c" and then that the "-I" option
// is not modified to include the current directory.
// There is an example problem demonstated by the compilation of file.c in ffmpeg-1.2.
// But I don't know how to reproduce the problem as a simple test.
// #include "config.h"
// #include "file.h"
// #include "log.h"
// #include "mem.h"
/* DQ (9/14/2013): Added include for Linux */
// #include <time.h>
// struct timespec {};
// #define _XOPEN_SOURCE 600
// #define __USE_MISC
#include <fcntl.h>
#include <sys/stat.h>
|
the_stack_data/78117.c |
void set(int *a)
{
*a = 8;
}
/* globals are initialized by
* ConstantExpr, so this is different
* test thatn funcptr1.c */
void (*s)(int *) = set;
int main(void)
{
int a, b, c;
a = b + c;
b = 3;
c = 5;
s(&a);
test_assert(a == 8);
return 0;
}
|
the_stack_data/211079641.c | #include <stdio.h>
#include<stdlib.h>
int main(void)
{
int no1, no2, ans;
char op;
printf("\n Enter No1 :: ");
scanf("%d", &no1);
printf("\n Enter op :: ");
getchar();
scanf("%c", &op);
// scanf("%*c%c", &op); // %*c ingore char \n
printf("\n Enter No2 :: ");
scanf("%d", &no2);
ans=0;
/*
// simple if
if(op=='+')
ans= no1+no2;
if(op=='-')
ans= no1-no2;
if(op=='*')
ans= no1*no2;
if(op=='/')
ans= no1/no2;*/
// nested if
/*if(op=='+')
ans= no1+no2;
else if(op=='-')
ans= no1-no2;
else if(op=='*')
ans= no1*no2;
else if(op=='/')
{
if(no2==0)
{
printf("\n can not divide by zreo");
return 0;
//exit(0);//
}
else
ans= no1/no2;
}
else
{
printf("\n invalid operator");
exit(0);
}
*/
switch(op)
{
case '+' : // addition
ans= no1+no2; break;//continue;
case '-' : // sub
ans= no1-no2; break;
case '*' : // multiply
ans= no1*no2; break;
case '/' : // div
if(no2==0)
{
printf("\n can not divide by zero");
exit(0);
}
else
ans= no1/no2;
break;
default: printf("\n invalid operator");
exit(0); // break;
}
printf(" %d %c %d = %d", no1, op, no2, ans);
return 0;
}
|
the_stack_data/243893365.c | // Author: Chungha Sung
// This is a modified version of Blink LED Demo from
// http://processors.wiki.ti.com/index.php/MSP430_LaunchPad_LED_Timer
// Below is the original source code and C version of this code.
//***************************************************************************************
// MSP430 Timer Blink LED Demo - Timer A Software Toggle P1.0 & P1.6
//
// Description; Toggle P1.0 and P1.6 by xor'ing them inside of a software loop.
// Since the clock is running at 1Mhz, an overflow counter will count to 8 and then toggle
// the LED. This way the LED toggles every 0.5s.
// ACLK = n/a, MCLK = SMCLK = default DCO
//
// MSP430G2xx
// -----------------
// /|\| XIN|-
// | | |
// --|RST XOUT|-
// | P1.6|-->LED
// | P1.0|-->LED
//
// Aldo Briano
// Texas Instruments, Inc
// June 2010
// Built with Code Composer Studio v4
//***************************************************************************************
/*
#include <msp430g2231.h>
#define LED_0 BIT0
#define LED_1 BIT6
#define LED_OUT P1OUT
#define LED_DIR P1DIR
unsigned int timerCount = 0;
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
LED_DIR |= (LED_0 + LED_1); // Set P1.0 and P1.6 to output direction
LED_OUT &= ~(LED_0 + LED_1); // Set the LEDs off
CCTL0 = CCIE;
TACTL = TASSEL_2 + MC_2; // Set the timer A to SMCLCK, Continuous
// Clear the timer and enable timer interrupt
__enable_interrupt();
__bis_SR_register(LPM0 + GIE); // LPM0 with interrupts enabled
}
// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
timerCount = (timerCount + 1) % 8;
if(timerCount ==0)
P1OUT ^= (LED_0 + LED_1);
}
*/
#include <stdio.h>
#include <pthread.h>
#include <assert.h>
unsigned int timerCount = 0;
int P1OUT;
int LED_0;
int LED_1;
int WDTCLT;
int WDTPW;
int WDTCTL;
int WDTHOLD;
int LED_DIR;
int LED_OUT;
int CCTL0;
int CCIE;
int TACTL;
int TASSEL_2;
int MC_2;
#define LIMIT 20
int cnt1, cnt2, cnt3;
// Timer A0 interrupt service routine
// Priority 2
void *Timer_A (void *unused)
{
//while (cnt1 < LIMIT) {
//timerCount = (timerCount + 1) % 8;
timerCount = 1;
//timerCount++;
// assert(timerCount == 0);
// traditional: violated
// our method: violated
if (timerCount != 0) {
assert(0);
}
if(timerCount == 0) {
P1OUT = (LED_0 + LED_1);
}
//cnt1++;
//}
}
// Priority 2
void *Timer_B (void *unused)
{
//while (cnt2 < LIMIT) {
//timerCount = (timerCount + 1) % 4;
timerCount = 1;
// assert(timerCount == 0);
// traditional: violated
// our method: violated
if (timerCount != 0) {
assert(0);
}
if (timerCount == 0) {
P1OUT = LED_0;
}
//cnt2++;
//}
}
// Priority 3
void *Timer_Force (void* unused)
{
//while (cnt3 < LIMIT) {
// traditional: violated
// our method: not violated
timerCount = 0;
if (timerCount != 0) {
assert(0);
}
timerCount = 1;
//cnt3++;
//}
}
int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer
//LED_DIR |= (LED_0 + LED_1); // Set P1.0 and P1.6 to output direction
LED_DIR = LED_0 + LED_1;
//LED_OUT &= ~(LED_0 + LED_1); // Set the LEDs off
LED_OUT = 1 + (LED_0+LED_1);
CCTL0 = CCIE;
TACTL = TASSEL_2 + MC_2; // Set the timer A to SMCLCK, Continuous
// Clear the timer and enable timer interrupt
timerCount = 0;
pthread_t t1, t2, t3;
pthread_create(&t1, 0, Timer_A, 0);
pthread_create(&t2, 0, Timer_B, 0);
pthread_create(&t3, 0, Timer_Force, 0);
//__bis_SR_register(LPM0 + GIE); // LPM0 with interrupts enabled
}
|
the_stack_data/242330832.c | #include <stdio.h>
int main()
{
int reg; scanf("%d", ®);
if (reg < 2)
{
printf("Nordeste\n");
}
else if (reg < 3)
{
printf("Norte\n");
}
else if (reg < 5)
{
printf("Centro-Oeste\n");
}
else if (reg < 10)
{
printf("Sul\n");
}
else
{
printf("Sudeste\n");
}
}
|
the_stack_data/659763.c | /*
* $Id: dlmalloc.c,v 1.2 1998/09/23 17:16:10 wessels Exp $
*/
/* ---------- To make a malloc.h, start cutting here ------------ */
/*
A version of malloc/free/realloc written by Doug Lea and released to the
public domain. Send questions/comments/complaints/performance data
to [email protected]
* VERSION 2.6.4 Thu Nov 28 07:54:55 1996 Doug Lea (dl at gee)
Note: There may be an updated version of this malloc obtainable at
ftp://g.oswego.edu/pub/misc/malloc.c
Check before installing!
* Why use this malloc?
This is not the fastest, most space-conserving, most portable, or
most tunable malloc ever written. However it is among the fastest
while also being among the most space-conserving, portable and tunable.
Consistent balance across these factors results in a good general-purpose
allocator. For a high-level description, see
http://g.oswego.edu/dl/html/malloc.html
* Synopsis of public routines
(Much fuller descriptions are contained in the program documentation below.)
malloc(size_t n);
Return a pointer to a newly allocated chunk of at least n bytes, or null
if no space is available.
free(Void_t* p);
Release the chunk of memory pointed to by p, or no effect if p is null.
realloc(Void_t* p, size_t n);
Return a pointer to a chunk of size n that contains the same data
as does chunk p up to the minimum of (n, p's size) bytes, or null
if no space is available. The returned pointer may or may not be
the same as p. If p is null, equivalent to malloc. Unless the
#define REALLOC_ZERO_BYTES_FREES below is set, realloc with a
size argument of zero (re)allocates a minimum-sized chunk.
memalign(size_t alignment, size_t n);
Return a pointer to a newly allocated chunk of n bytes, aligned
in accord with the alignment argument, which must be a power of
two.
valloc(size_t n);
Equivalent to memalign(pagesize, n), where pagesize is the page
size of the system (or as near to this as can be figured out from
all the includes/defines below.)
pvalloc(size_t n);
Equivalent to valloc(minimum-page-that-holds(n)), that is,
round up n to nearest pagesize.
calloc(size_t unit, size_t quantity);
Returns a pointer to quantity * unit bytes, with all locations
set to zero.
cfree(Void_t* p);
Equivalent to free(p).
malloc_trim(size_t pad);
Release all but pad bytes of freed top-most memory back
to the system. Return 1 if successful, else 0.
malloc_usable_size(Void_t* p);
Report the number usable allocated bytes associated with allocated
chunk p. This may or may not report more bytes than were requested,
due to alignment and minimum size constraints.
malloc_stats();
Prints brief summary statistics on stderr.
mallinfo()
Returns (by copy) a struct containing various summary statistics.
mallopt(int parameter_number, int parameter_value)
Changes one of the tunable parameters described below. Returns
1 if successful in changing the parameter, else 0.
* Vital statistics:
Alignment: 8-byte
8 byte alignment is currently hardwired into the design. This
seems to suffice for all current machines and C compilers.
Assumed pointer representation: 4 or 8 bytes
Code for 8-byte pointers is untested by me but has worked
reliably by Wolfram Gloger, who contributed most of the
changes supporting this.
Assumed size_t representation: 4 or 8 bytes
Note that size_t is allowed to be 4 bytes even if pointers are 8.
Minimum overhead per allocated chunk: 4 or 8 bytes
Each malloced chunk has a hidden overhead of 4 bytes holding size
and status information.
Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
needed; 4 (8) for a trailing size field
and 8 (16) bytes for free list pointers. Thus, the minimum
allocatable size is 16/24/32 bytes.
Even a request for zero bytes (i.e., malloc(0)) returns a
pointer to something of the minimum allocatable size.
Maximum allocated size: 4-byte size_t: 2^31 - 8 bytes
8-byte size_t: 2^63 - 16 bytes
It is assumed that (possibly signed) size_t bit values suffice to
represent chunk sizes. `Possibly signed' is due to the fact
that `size_t' may be defined on a system as either a signed or
an unsigned type. To be conservative, values that would appear
as negative numbers are avoided.
Requests for sizes with a negative sign bit will return a
minimum-sized chunk.
Maximum overhead wastage per allocated chunk: normally 15 bytes
Alignnment demands, plus the minimum allocatable size restriction
make the normal worst-case wastage 15 bytes (i.e., up to 15
more bytes will be allocated than were requested in malloc), with
two exceptions:
1. Because requests for zero bytes allocate non-zero space,
the worst case wastage for a request of zero bytes is 24 bytes.
2. For requests >= mmap_threshold that are serviced via
mmap(), the worst case wastage is 8 bytes plus the remainder
from a system page (the minimal mmap unit); typically 4096 bytes.
* Limitations
Here are some features that are NOT currently supported
* No user-definable hooks for callbacks and the like.
* No automated mechanism for fully checking that all accesses
to malloced memory stay within their bounds.
* No support for compaction.
* Synopsis of compile-time options:
People have reported using previous versions of this malloc on all
versions of Unix, sometimes by tweaking some of the defines
below. It has been tested most extensively on Solaris and
Linux. It is also reported to work on WIN32 platforms.
People have also reported adapting this malloc for use in
stand-alone embedded systems.
The implementation is in straight, hand-tuned ANSI C. Among other
consequences, it uses a lot of macros. Because of this, to be at
all usable, this code should be compiled using an optimizing compiler
(for example gcc -O2) that can simplify expressions and control
paths.
__STD_C (default: derived from C compiler defines)
Nonzero if using ANSI-standard C compiler, a C++ compiler, or
a C compiler sufficiently close to ANSI to get away with it.
DEBUG (default: NOT defined)
Define to enable debugging. Adds fairly extensive assertion-based
checking to help track down memory errors, but noticeably slows down
execution.
REALLOC_ZERO_BYTES_FREES (default: NOT defined)
Define this if you think that realloc(p, 0) should be equivalent
to free(p). Otherwise, since malloc returns a unique pointer for
malloc(0), so does realloc(p, 0).
HAVE_MEMCPY (default: defined)
Define if you are not otherwise using ANSI STD C, but still
have memcpy and memset in your C library and want to use them.
Otherwise, simple internal versions are supplied.
USE_MEMCPY (default: 1 if HAVE_MEMCPY is defined, 0 otherwise)
Define as 1 if you want the C library versions of memset and
memcpy called in realloc and calloc (otherwise macro versions are used).
At least on some platforms, the simple macro versions usually
outperform libc versions.
HAVE_MMAP (default: defined as 1)
Define to non-zero to optionally make malloc() use mmap() to
allocate very large blocks.
HAVE_MREMAP (default: defined as 0 unless Linux libc set)
Define to non-zero to optionally make realloc() use mremap() to
reallocate very large blocks.
malloc_getpagesize (default: derived from system #includes)
Either a constant or routine call returning the system page size.
HAVE_USR_INCLUDE_MALLOC_H (default: NOT defined)
Optionally define if you are on a system with a /usr/include/malloc.h
that declares struct mallinfo. It is not at all necessary to
define this even if you do, but will ensure consistency.
INTERNAL_SIZE_T (default: size_t)
Define to a 32-bit type (probably `unsigned int') if you are on a
64-bit machine, yet do not want or need to allow malloc requests of
greater than 2^31 to be handled. This saves space, especially for
very small chunks.
INTERNAL_LINUX_C_LIB (default: NOT defined)
Defined only when compiled as part of Linux libc.
Also note that there is some odd internal name-mangling via defines
(for example, internally, `malloc' is named `mALLOc') needed
when compiling in this case. These look funny but don't otherwise
affect anything.
WIN32 (default: undefined)
Define this on MS win (95, nt) platforms to compile in sbrk emulation.
LACKS_UNISTD_H (default: undefined)
Define this if your system does not have a <unistd.h>.
MORECORE (default: sbrk)
The name of the routine to call to obtain more memory from the system.
MORECORE_FAILURE (default: -1)
The value returned upon failure of MORECORE.
MORECORE_CLEARS (default 1)
True (1) if the routine mapped to MORECORE zeroes out memory (which
holds for sbrk).
DEFAULT_TRIM_THRESHOLD
DEFAULT_TOP_PAD
DEFAULT_MMAP_THRESHOLD
DEFAULT_MMAP_MAX
Default values of tunable parameters (described in detail below)
controlling interaction with host system routines (sbrk, mmap, etc).
These values may also be changed dynamically via mallopt(). The
preset defaults are those that give best performance for typical
programs/systems.
*/
/* Preliminaries */
#ifndef __STD_C
#ifdef __STDC__
#define __STD_C 1
#else
#if __cplusplus
#define __STD_C 1
#else
#define __STD_C 0
#endif /*__cplusplus*/
#endif /*__STDC__*/
#endif /*__STD_C*/
#ifndef Void_t
#if __STD_C
#define Void_t void
#else
#define Void_t char
#endif
#endif /*Void_t*/
#if __STD_C
#include <stddef.h> /* for size_t */
#else
#include <sys/types.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h> /* needed for malloc_stats */
/*
Compile-time options
*/
/*
Debugging:
Because freed chunks may be overwritten with link fields, this
malloc will often die when freed memory is overwritten by user
programs. This can be very effective (albeit in an annoying way)
in helping track down dangling pointers.
If you compile with -DDEBUG, a number of assertion checks are
enabled that will catch more memory errors. You probably won't be
able to make much sense of the actual assertion errors, but they
should help you locate incorrectly overwritten memory. The
checking is fairly extensive, and will slow down execution
noticeably. Calling malloc_stats or mallinfo with DEBUG set will
attempt to check every non-mmapped allocated and free chunk in the
course of computing the summmaries. (By nature, mmapped regions
cannot be checked very much automatically.)
Setting DEBUG may also be helpful if you are trying to modify
this code. The assertions in the check routines spell out in more
detail the assumptions and invariants underlying the algorithms.
*/
#if DEBUG
#include <assert.h>
#else
#define assert(x) ((void)0)
#endif
/*
INTERNAL_SIZE_T is the word-size used for internal bookkeeping
of chunk sizes. On a 64-bit machine, you can reduce malloc
overhead by defining INTERNAL_SIZE_T to be a 32 bit `unsigned int'
at the expense of not being able to handle requests greater than
2^31. This limitation is hardly ever a concern; you are encouraged
to set this. However, the default version is the same as size_t.
*/
#ifndef INTERNAL_SIZE_T
#define INTERNAL_SIZE_T size_t
#endif
/*
REALLOC_ZERO_BYTES_FREES should be set if a call to
realloc with zero bytes should be the same as a call to free.
Some people think it should. Otherwise, since this malloc
returns a unique pointer for malloc(0), so does realloc(p, 0).
*/
/* #define REALLOC_ZERO_BYTES_FREES */
/*
WIN32 causes an emulation of sbrk to be compiled in
mmap-based options are not currently supported in WIN32.
*/
/* #define WIN32 */
#ifdef WIN32
#define MORECORE wsbrk
#define HAVE_MMAP 0
#endif
/*
HAVE_MEMCPY should be defined if you are not otherwise using
ANSI STD C, but still have memcpy and memset in your C library
and want to use them in calloc and realloc. Otherwise simple
macro versions are defined here.
USE_MEMCPY should be defined as 1 if you actually want to
have memset and memcpy called. People report that the macro
versions are often enough faster than libc versions on many
systems that it is better to use them.
*/
#define HAVE_MEMCPY
#ifndef USE_MEMCPY
#ifdef HAVE_MEMCPY
#define USE_MEMCPY 1
#else
#define USE_MEMCPY 0
#endif
#endif
#if (__STD_C || defined(HAVE_MEMCPY))
#if __STD_C
void* memset(void*, int, size_t);
void* memcpy(void*, const void*, size_t);
#else
Void_t* memset();
Void_t* memcpy();
#endif
#endif
#if USE_MEMCPY
/* The following macros are only invoked with (2n+1)-multiples of
INTERNAL_SIZE_T units, with a positive integer n. This is exploited
for fast inline execution when n is small. */
#define MALLOC_ZERO(charp, nbytes) \
do { \
INTERNAL_SIZE_T mzsz = (nbytes); \
if(mzsz <= 9*sizeof(mzsz)) { \
INTERNAL_SIZE_T* mz = (INTERNAL_SIZE_T*) (charp); \
if(mzsz >= 5*sizeof(mzsz)) { *mz++ = 0; \
*mz++ = 0; \
if(mzsz >= 7*sizeof(mzsz)) { *mz++ = 0; \
*mz++ = 0; \
if(mzsz >= 9*sizeof(mzsz)) { *mz++ = 0; \
*mz++ = 0; }}} \
*mz++ = 0; \
*mz++ = 0; \
*mz = 0; \
} else memset((charp), 0, mzsz); \
} while(0)
#define MALLOC_COPY(dest,src,nbytes) \
do { \
INTERNAL_SIZE_T mcsz = (nbytes); \
if(mcsz <= 9*sizeof(mcsz)) { \
INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) (src); \
INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) (dest); \
if(mcsz >= 5*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \
*mcdst++ = *mcsrc++; \
if(mcsz >= 7*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \
*mcdst++ = *mcsrc++; \
if(mcsz >= 9*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \
*mcdst++ = *mcsrc++; }}} \
*mcdst++ = *mcsrc++; \
*mcdst++ = *mcsrc++; \
*mcdst = *mcsrc ; \
} else memcpy(dest, src, mcsz); \
} while(0)
#else /* !USE_MEMCPY */
/* Use Duff's device for good zeroing/copying performance. */
#define MALLOC_ZERO(charp, nbytes) \
do { \
INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \
if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
switch (mctmp) { \
case 0: for(;;) { *mzp++ = 0; \
case 7: *mzp++ = 0; \
case 6: *mzp++ = 0; \
case 5: *mzp++ = 0; \
case 4: *mzp++ = 0; \
case 3: *mzp++ = 0; \
case 2: *mzp++ = 0; \
case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
} \
} while(0)
#define MALLOC_COPY(dest,src,nbytes) \
do { \
INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \
if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
switch (mctmp) { \
case 0: for(;;) { *mcdst++ = *mcsrc++; \
case 7: *mcdst++ = *mcsrc++; \
case 6: *mcdst++ = *mcsrc++; \
case 5: *mcdst++ = *mcsrc++; \
case 4: *mcdst++ = *mcsrc++; \
case 3: *mcdst++ = *mcsrc++; \
case 2: *mcdst++ = *mcsrc++; \
case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
} \
} while(0)
#endif
/*
Define HAVE_MMAP to optionally make malloc() use mmap() to
allocate very large blocks. These will be returned to the
operating system immediately after a free().
*/
#ifndef HAVE_MMAP
#define HAVE_MMAP 1
#endif
/*
Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
large blocks. This is currently only possible on Linux with
kernel versions newer than 1.3.77.
*/
#ifndef HAVE_MREMAP
#ifdef INTERNAL_LINUX_C_LIB
#define HAVE_MREMAP 1
#else
#define HAVE_MREMAP 0
#endif
#endif
#if HAVE_MMAP
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
#define MAP_ANONYMOUS MAP_ANON
#endif
#endif /* HAVE_MMAP */
/*
Access to system page size. To the extent possible, this malloc
manages memory from the system in page-size units.
The following mechanics for getpagesize were adapted from
bsd/gnu getpagesize.h
*/
#ifndef LACKS_UNISTD_H
# include <unistd.h>
#endif
#ifndef malloc_getpagesize
# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */
# ifndef _SC_PAGE_SIZE
# define _SC_PAGE_SIZE _SC_PAGESIZE
# endif
# endif
# ifdef _SC_PAGE_SIZE
# define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
# else
# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
extern size_t getpagesize();
# define malloc_getpagesize getpagesize()
# else
# include <sys/param.h>
# ifdef EXEC_PAGESIZE
# define malloc_getpagesize EXEC_PAGESIZE
# else
# ifdef NBPG
# ifndef CLSIZE
# define malloc_getpagesize NBPG
# else
# define malloc_getpagesize (NBPG * CLSIZE)
# endif
# else
# ifdef NBPC
# define malloc_getpagesize NBPC
# else
# ifdef PAGESIZE
# define malloc_getpagesize PAGESIZE
# else
# define malloc_getpagesize (4096) /* just guess */
# endif
# endif
# endif
# endif
# endif
# endif
#endif
/*
This version of malloc supports the standard SVID/XPG mallinfo
routine that returns a struct containing the same kind of
information you can get from malloc_stats. It should work on
any SVID/XPG compliant system that has a /usr/include/malloc.h
defining struct mallinfo. (If you'd like to install such a thing
yourself, cut out the preliminary declarations as described above
and below and save them in a malloc.h file. But there's no
compelling reason to bother to do this.)
The main declaration needed is the mallinfo struct that is returned
(by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
bunch of fields, most of which are not even meaningful in this
version of malloc. Some of these fields are are instead filled by
mallinfo() with other numbers that might possibly be of interest.
HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
/usr/include/malloc.h file that includes a declaration of struct
mallinfo. If so, it is included; else an SVID2/XPG2 compliant
version is declared below. These must be precisely the same for
mallinfo() to work.
*/
/* #define HAVE_USR_INCLUDE_MALLOC_H */
#if HAVE_USR_INCLUDE_MALLOC_H
#include "/usr/include/malloc.h"
#else
/* SVID2/XPG mallinfo structure */
struct mallinfo {
int arena; /* total space allocated from system */
int ordblks; /* number of non-inuse chunks */
int smblks; /* unused -- always zero */
int hblks; /* number of mmapped regions */
int hblkhd; /* total space in mmapped regions */
int usmblks; /* unused -- always zero */
int fsmblks; /* unused -- always zero */
int uordblks; /* total allocated space */
int fordblks; /* total non-inuse space */
int keepcost; /* top-most, releasable (via malloc_trim) space */
};
/* SVID2/XPG mallopt options */
#define M_MXFAST 1 /* UNUSED in this malloc */
#define M_NLBLKS 2 /* UNUSED in this malloc */
#define M_GRAIN 3 /* UNUSED in this malloc */
#define M_KEEP 4 /* UNUSED in this malloc */
#endif
/* mallopt options that actually do something */
#define M_TRIM_THRESHOLD -1
#define M_TOP_PAD -2
#define M_MMAP_THRESHOLD -3
#define M_MMAP_MAX -4
#ifndef DEFAULT_TRIM_THRESHOLD
#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
#endif
/*
M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
to keep before releasing via malloc_trim in free().
Automatic trimming is mainly useful in long-lived programs.
Because trimming via sbrk can be slow on some systems, and can
sometimes be wasteful (in cases where programs immediately
afterward allocate more large chunks) the value should be high
enough so that your overall system performance would improve by
releasing.
The trim threshold and the mmap control parameters (see below)
can be traded off with one another. Trimming and mmapping are
two different ways of releasing unused memory back to the
system. Between these two, it is often possible to keep
system-level demands of a long-lived program down to a bare
minimum. For example, in one test suite of sessions measuring
the XF86 X server on Linux, using a trim threshold of 128K and a
mmap threshold of 192K led to near-minimal long term resource
consumption.
If you are using this malloc in a long-lived program, it should
pay to experiment with these values. As a rough guide, you
might set to a value close to the average size of a process
(program) running on your system. Releasing this much memory
would allow such a process to run in memory. Generally, it's
worth it to tune for trimming rather tham memory mapping when a
program undergoes phases where several large chunks are
allocated and released in ways that can reuse each other's
storage, perhaps mixed with phases where there are no such
chunks at all. And in well-behaved long-lived programs,
controlling release of large blocks via trimming versus mapping
is usually faster.
However, in most programs, these parameters serve mainly as
protection against the system-level effects of carrying around
massive amounts of unneeded memory. Since frequent calls to
sbrk, mmap, and munmap otherwise degrade performance, the default
parameters are set to relatively high values that serve only as
safeguards.
The default trim value is high enough to cause trimming only in
fairly extreme (by current memory consumption standards) cases.
It must be greater than page size to have any useful effect. To
disable trimming completely, you can set to (unsigned long)(-1);
*/
#ifndef DEFAULT_TOP_PAD
#define DEFAULT_TOP_PAD (0)
#endif
/*
M_TOP_PAD is the amount of extra `padding' space to allocate or
retain whenever sbrk is called. It is used in two ways internally:
* When sbrk is called to extend the top of the arena to satisfy
a new malloc request, this much padding is added to the sbrk
request.
* When malloc_trim is called automatically from free(),
it is used as the `pad' argument.
In both cases, the actual amount of padding is rounded
so that the end of the arena is always a system page boundary.
The main reason for using padding is to avoid calling sbrk so
often. Having even a small pad greatly reduces the likelihood
that nearly every malloc request during program start-up (or
after trimming) will invoke sbrk, which needlessly wastes
time.
Automatic rounding-up to page-size units is normally sufficient
to avoid measurable overhead, so the default is 0. However, in
systems where sbrk is relatively slow, it can pay to increase
this value, at the expense of carrying around more memory than
the program needs.
*/
#ifndef DEFAULT_MMAP_THRESHOLD
#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
#endif
/*
M_MMAP_THRESHOLD is the request size threshold for using mmap()
to service a request. Requests of at least this size that cannot
be allocated using already-existing space will be serviced via mmap.
(If enough normal freed space already exists it is used instead.)
Using mmap segregates relatively large chunks of memory so that
they can be individually obtained and released from the host
system. A request serviced through mmap is never reused by any
other request (at least not directly; the system may just so
happen to remap successive requests to the same locations).
Segregating space in this way has the benefit that mmapped space
can ALWAYS be individually released back to the system, which
helps keep the system level memory demands of a long-lived
program low. Mapped memory can never become `locked' between
other chunks, as can happen with normally allocated chunks, which
menas that even trimming via malloc_trim would not release them.
However, it has the disadvantages that:
1. The space cannot be reclaimed, consolidated, and then
used to service later requests, as happens with normal chunks.
2. It can lead to more wastage because of mmap page alignment
requirements
3. It causes malloc performance to be more dependent on host
system memory management support routines which may vary in
implementation quality and may impose arbitrary
limitations. Generally, servicing a request via normal
malloc steps is faster than going through a system's mmap.
All together, these considerations should lead you to use mmap
only for relatively large requests.
*/
#ifndef DEFAULT_MMAP_MAX
#if HAVE_MMAP
#define DEFAULT_MMAP_MAX (64)
#else
#define DEFAULT_MMAP_MAX (0)
#endif
#endif
/*
M_MMAP_MAX is the maximum number of requests to simultaneously
service using mmap. This parameter exists because:
1. Some systems have a limited number of internal tables for
use by mmap.
2. In most systems, overreliance on mmap can degrade overall
performance.
3. If a program allocates many large regions, it is probably
better off using normal sbrk-based allocation routines that
can reclaim and reallocate normal heap memory. Using a
small value allows transition into this mode after the
first few allocations.
Setting to 0 disables all use of mmap. If HAVE_MMAP is not set,
the default value is 0, and attempts to set it to non-zero values
in mallopt will fail.
*/
/*
Special defines for linux libc
Except when compiled using these special defines for Linux libc
using weak aliases, this malloc is NOT designed to work in
multithreaded applications. No semaphores or other concurrency
control are provided to ensure that multiple malloc or free calls
don't run at the same time, which could be disasterous. A single
semaphore could be used across malloc, realloc, and free (which is
essentially the effect of the linux weak alias approach). It would
be hard to obtain finer granularity.
*/
#ifdef INTERNAL_LINUX_C_LIB
#if __STD_C
Void_t * __default_morecore_init (ptrdiff_t);
Void_t *(*__morecore)(ptrdiff_t) = __default_morecore_init;
#else
Void_t * __default_morecore_init ();
Void_t *(*__morecore)() = __default_morecore_init;
#endif
#define MORECORE (*__morecore)
#define MORECORE_FAILURE 0
#define MORECORE_CLEARS 1
#else /* INTERNAL_LINUX_C_LIB */
#if __STD_C
extern Void_t* sbrk(ptrdiff_t);
#else
extern Void_t* sbrk();
#endif
#ifndef MORECORE
#define MORECORE sbrk
#endif
#ifndef MORECORE_FAILURE
#define MORECORE_FAILURE -1
#endif
#ifndef MORECORE_CLEARS
#define MORECORE_CLEARS 1
#endif
#endif /* INTERNAL_LINUX_C_LIB */
#if defined(INTERNAL_LINUX_C_LIB) && defined(__ELF__)
#define cALLOc __libc_calloc
#define fREe __libc_free
#define mALLOc __libc_malloc
#define mEMALIGn __libc_memalign
#define rEALLOc __libc_realloc
#define vALLOc __libc_valloc
#define pvALLOc __libc_pvalloc
#define mALLINFo __libc_mallinfo
#define mALLOPt __libc_mallopt
#pragma weak calloc = __libc_calloc
#pragma weak free = __libc_free
#pragma weak cfree = __libc_free
#pragma weak malloc = __libc_malloc
#pragma weak memalign = __libc_memalign
#pragma weak realloc = __libc_realloc
#pragma weak valloc = __libc_valloc
#pragma weak pvalloc = __libc_pvalloc
#pragma weak mallinfo = __libc_mallinfo
#pragma weak mallopt = __libc_mallopt
#else
#define cALLOc calloc
#define fREe free
#define mALLOc malloc
#define mEMALIGn memalign
#define rEALLOc realloc
#define vALLOc valloc
#define pvALLOc pvalloc
#define mALLINFo mallinfo
#define mALLOPt mallopt
#endif
/* Public routines */
#if __STD_C
Void_t* mALLOc(size_t);
void fREe(Void_t*);
Void_t* rEALLOc(Void_t*, size_t);
Void_t* mEMALIGn(size_t, size_t);
Void_t* vALLOc(size_t);
Void_t* pvALLOc(size_t);
Void_t* cALLOc(size_t, size_t);
void cfree(Void_t*);
int malloc_trim(size_t);
size_t malloc_usable_size(Void_t*);
void malloc_stats();
int mALLOPt(int, int);
struct mallinfo mALLINFo(void);
#else
Void_t* mALLOc();
void fREe();
Void_t* rEALLOc();
Void_t* mEMALIGn();
Void_t* vALLOc();
Void_t* pvALLOc();
Void_t* cALLOc();
void cfree();
int malloc_trim();
size_t malloc_usable_size();
void malloc_stats();
int mALLOPt();
struct mallinfo mALLINFo();
#endif
#ifdef __cplusplus
}; /* end of extern "C" */
#endif
/* ---------- To make a malloc.h, end cutting here ------------ */
/*
Emulation of sbrk for WIN32
All code within the ifdef WIN32 is untested by me.
*/
#ifdef WIN32
#define AlignPage(add) (((add) + (malloc_getpagesize-1)) &
~(malloc_getpagesize-1))
/* resrve 64MB to insure large contiguous space */
#define RESERVED_SIZE (1024*1024*64)
#define NEXT_SIZE (2048*1024)
#define TOP_MEMORY ((unsigned long)2*1024*1024*1024)
struct GmListElement;
typedef struct GmListElement GmListElement;
struct GmListElement
{
GmListElement* next;
void* base;
};
static GmListElement* head = 0;
static unsigned int gNextAddress = 0;
static unsigned int gAddressBase = 0;
static unsigned int gAllocatedSize = 0;
static
GmListElement* makeGmListElement (void* bas)
{
GmListElement* this;
this = (GmListElement*)(void*)LocalAlloc (0, sizeof (GmListElement));
ASSERT (this);
if (this)
{
this->base = bas;
this->next = head;
head = this;
}
return this;
}
void gcleanup ()
{
BOOL rval;
ASSERT ( (head == NULL) || (head->base == (void*)gAddressBase));
if (gAddressBase && (gNextAddress - gAddressBase))
{
rval = VirtualFree ((void*)gAddressBase,
gNextAddress - gAddressBase,
MEM_DECOMMIT);
ASSERT (rval);
}
while (head)
{
GmListElement* next = head->next;
rval = VirtualFree (head->base, 0, MEM_RELEASE);
ASSERT (rval);
LocalFree (head);
head = next;
}
}
static
void* findRegion (void* start_address, unsigned long size)
{
MEMORY_BASIC_INFORMATION info;
while ((unsigned long)start_address < TOP_MEMORY)
{
VirtualQuery (start_address, &info, sizeof (info));
if (info.State != MEM_FREE)
start_address = (char*)info.BaseAddress + info.RegionSize;
else if (info.RegionSize >= size)
return start_address;
else
start_address = (char*)info.BaseAddress + info.RegionSize;
}
return NULL;
}
void* wsbrk (long size)
{
void* tmp;
if (size > 0)
{
if (gAddressBase == 0)
{
gAllocatedSize = max (RESERVED_SIZE, AlignPage (size));
gNextAddress = gAddressBase =
(unsigned int)VirtualAlloc (NULL, gAllocatedSize,
MEM_RESERVE, PAGE_NOACCESS);
} else if (AlignPage (gNextAddress + size) > (gAddressBase +
gAllocatedSize))
{
long new_size = max (NEXT_SIZE, AlignPage (size));
void* new_address = (void*)(gAddressBase+gAllocatedSize);
do
{
new_address = findRegion (new_address, new_size);
if (new_address == 0)
return (void*)-1;
gAddressBase = gNextAddress =
(unsigned int)VirtualAlloc (new_address, new_size,
MEM_RESERVE, PAGE_NOACCESS);
// repeat in case of race condition
// The region that we found has been snagged
// by another thread
}
while (gAddressBase == 0);
ASSERT (new_address == (void*)gAddressBase);
gAllocatedSize = new_size;
if (!makeGmListElement ((void*)gAddressBase))
return (void*)-1;
}
if ((size + gNextAddress) > AlignPage (gNextAddress))
{
void* res;
res = VirtualAlloc ((void*)AlignPage (gNextAddress),
(size + gNextAddress -
AlignPage (gNextAddress)),
MEM_COMMIT, PAGE_READWRITE);
if (res == 0)
return (void*)-1;
}
tmp = (void*)gNextAddress;
gNextAddress = (unsigned int)tmp + size;
return tmp;
}
else if (size < 0)
{
unsigned int alignedGoal = AlignPage (gNextAddress + size);
/* Trim by releasing the virtual memory */
if (alignedGoal >= gAddressBase)
{
VirtualFree ((void*)alignedGoal, gNextAddress - alignedGoal,
MEM_DECOMMIT);
gNextAddress = gNextAddress + size;
return (void*)gNextAddress;
}
else
{
VirtualFree ((void*)gAddressBase, gNextAddress - gAddressBase,
MEM_DECOMMIT);
gNextAddress = gAddressBase;
return (void*)-1;
}
}
else
{
return (void*)gNextAddress;
}
}
#endif
/*
Type declarations
*/
struct malloc_chunk
{
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
};
typedef struct malloc_chunk* mchunkptr;
/*
malloc_chunk details:
(The following includes lightly edited explanations by Colin Plumb.)
Chunks of memory are maintained using a `boundary tag' method as
described in e.g., Knuth or Standish. (See the paper by Paul
Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
survey of such techniques.) Sizes of free chunks are stored both
in the front of each chunk and at the end. This makes
consolidating fragmented chunks into bigger chunks very fast. The
size fields also hold bits representing whether chunks are free or
in use.
An allocated chunk looks like this:
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk, if allocated | |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| User data starts here... .
. .
. (malloc_usable_space() bytes) .
. |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Where "chunk" is the front of the chunk for the purpose of most of
the malloc code, but "mem" is the pointer that is returned to the
user. "Nextchunk" is the beginning of the next contiguous chunk.
Chunks always begin on even word boundries, so the mem portion
(which is returned to the user) is also on an even word boundary, and
thus double-word aligned.
Free chunks are stored in circular doubly-linked lists, and look like this:
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
`head:' | Size of chunk, in bytes |P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Forward pointer to next chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Back pointer to previous chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Unused space (may be 0 bytes long) .
. .
. |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
`foot:' | Size of chunk, in bytes |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
The P (PREV_INUSE) bit, stored in the unused low-order bit of the
chunk size (which is always a multiple of two words), is an in-use
bit for the *previous* chunk. If that bit is *clear*, then the
word before the current chunk size contains the previous chunk
size, and can be used to find the front of the previous chunk.
(The very first chunk allocated always has this bit set,
preventing access to non-existent (or non-owned) memory.)
Note that the `foot' of the current chunk is actually represented
as the prev_size of the NEXT chunk. (This makes it easier to
deal with alignments etc).
The two exceptions to all this are
1. The special chunk `top', which doesn't bother using the
trailing size field since there is no
next contiguous chunk that would have to index off it. (After
initialization, `top' is forced to always exist. If it would
become less than MINSIZE bytes long, it is replenished via
malloc_extend_top.)
2. Chunks allocated via mmap, which have the second-lowest-order
bit (IS_MMAPPED) set in their size fields. Because they are
never merged or traversed from any other chunk, they have no
foot size or inuse information.
Available chunks are kept in any of several places (all declared below):
* `av': An array of chunks serving as bin headers for consolidated
chunks. Each bin is doubly linked. The bins are approximately
proportionally (log) spaced. There are a lot of these bins
(128). This may look excessive, but works very well in
practice. All procedures maintain the invariant that no
consolidated chunk physically borders another one. Chunks in
bins are kept in size order, with ties going to the
approximately least recently used chunk.
The chunks in each bin are maintained in decreasing sorted order by
size. This is irrelevant for the small bins, which all contain
the same-sized chunks, but facilitates best-fit allocation for
larger chunks. (These lists are just sequential. Keeping them in
order almost never requires enough traversal to warrant using
fancier ordered data structures.) Chunks of the same size are
linked with the most recently freed at the front, and allocations
are taken from the back. This results in LRU or FIFO allocation
order, which tends to give each chunk an equal opportunity to be
consolidated with adjacent freed chunks, resulting in larger free
chunks and less fragmentation.
* `top': The top-most available chunk (i.e., the one bordering the
end of available memory) is treated specially. It is never
included in any bin, is used only if no other chunk is
available, and is released back to the system if it is very
large (see M_TRIM_THRESHOLD).
* `last_remainder': A bin holding only the remainder of the
most recently split (non-top) chunk. This bin is checked
before other non-fitting chunks, so as to provide better
locality for runs of sequentially allocated chunks.
* Implicitly, through the host system's memory mapping tables.
If supported, requests greater than a threshold are usually
serviced via calls to mmap, and then later released via munmap.
*/
/* sizes, alignments */
#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
#define MALLOC_ALIGNMENT (SIZE_SZ + SIZE_SZ)
#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
#define MINSIZE (sizeof(struct malloc_chunk))
/* conversion from malloc headers to user pointers, and back */
#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
/* pad request bytes into a usable size */
#define request2size(req) \
(((long)((req) + (SIZE_SZ + MALLOC_ALIGN_MASK)) < \
(long)(MINSIZE + MALLOC_ALIGN_MASK)) ? MINSIZE : \
(((req) + (SIZE_SZ + MALLOC_ALIGN_MASK)) & ~(MALLOC_ALIGN_MASK)))
/* Check if m has acceptable alignment */
#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
/*
Physical chunk operations
*/
/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
#define PREV_INUSE 0x1
/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
#define IS_MMAPPED 0x2
/* Bits to mask off when extracting size */
#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
/* Ptr to next physical malloc_chunk. */
#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
/* Ptr to previous physical malloc_chunk */
#define prev_chunk(p)\
((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
/* Treat space at ptr + offset as a chunk */
#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
/*
Dealing with use bits
*/
/* extract p's inuse bit */
#define inuse(p)\
((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
/* extract inuse bit of previous chunk */
#define prev_inuse(p) ((p)->size & PREV_INUSE)
/* check for mmap()'ed chunk */
#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
/* set/clear chunk as in use without otherwise disturbing */
#define set_inuse(p)\
((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
#define clear_inuse(p)\
((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
/* check/set/clear inuse bits in known places */
#define inuse_bit_at_offset(p, s)\
(((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
#define set_inuse_bit_at_offset(p, s)\
(((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
#define clear_inuse_bit_at_offset(p, s)\
(((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
/*
Dealing with size fields
*/
/* Get size, ignoring use bits */
#define chunksize(p) ((p)->size & ~(SIZE_BITS))
/* Set size at head, without disturbing its use bit */
#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
/* Set size/use ignoring previous bits in header */
#define set_head(p, s) ((p)->size = (s))
/* Set size at footer (only when chunk is not in use) */
#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
/*
Bins
The bins, `av_' are an array of pairs of pointers serving as the
heads of (initially empty) doubly-linked lists of chunks, laid out
in a way so that each pair can be treated as if it were in a
malloc_chunk. (This way, the fd/bk offsets for linking bin heads
and chunks are the same).
Bins for sizes < 512 bytes contain chunks of all the same size, spaced
8 bytes apart. Larger bins are approximately logarithmically
spaced. (See the table below.) The `av_' array is never mentioned
directly in the code, but instead via bin access macros.
Bin layout:
64 bins of size 8
32 bins of size 64
16 bins of size 512
8 bins of size 4096
4 bins of size 32768
2 bins of size 262144
1 bin of size what's left
There is actually a little bit of slop in the numbers in bin_index
for the sake of speed. This makes no difference elsewhere.
The special chunks `top' and `last_remainder' get their own bins,
(this is implemented via yet more trickery with the av_ array),
although `top' is never properly linked to its bin since it is
always handled specially.
*/
#define NAV 128 /* number of bins */
typedef struct malloc_chunk* mbinptr;
/* access macros */
#define bin_at(i) ((mbinptr)((char*)&(av_[2*(i) + 2]) - 2*SIZE_SZ))
#define next_bin(b) ((mbinptr)((char*)(b) + 2 * sizeof(mbinptr)))
#define prev_bin(b) ((mbinptr)((char*)(b) - 2 * sizeof(mbinptr)))
/*
The first 2 bins are never indexed. The corresponding av_ cells are instead
used for bookkeeping. This is not to save space, but to simplify
indexing, maintain locality, and avoid some initialization tests.
*/
#define top (bin_at(0)->fd) /* The topmost chunk */
#define last_remainder (bin_at(1)) /* remainder from last split */
/*
Because top initially points to its own bin with initial
zero size, thus forcing extension on the first malloc request,
we avoid having any special code in malloc to check whether
it even exists yet. But we still need to in malloc_extend_top.
*/
#define initial_top ((mchunkptr)(bin_at(0)))
/* Helper macro to initialize bins */
#define IAV(i) bin_at(i), bin_at(i)
static mbinptr av_[NAV * 2 + 2] = {
0, 0,
IAV(0), IAV(1), IAV(2), IAV(3), IAV(4), IAV(5), IAV(6), IAV(7),
IAV(8), IAV(9), IAV(10), IAV(11), IAV(12), IAV(13), IAV(14), IAV(15),
IAV(16), IAV(17), IAV(18), IAV(19), IAV(20), IAV(21), IAV(22), IAV(23),
IAV(24), IAV(25), IAV(26), IAV(27), IAV(28), IAV(29), IAV(30), IAV(31),
IAV(32), IAV(33), IAV(34), IAV(35), IAV(36), IAV(37), IAV(38), IAV(39),
IAV(40), IAV(41), IAV(42), IAV(43), IAV(44), IAV(45), IAV(46), IAV(47),
IAV(48), IAV(49), IAV(50), IAV(51), IAV(52), IAV(53), IAV(54), IAV(55),
IAV(56), IAV(57), IAV(58), IAV(59), IAV(60), IAV(61), IAV(62), IAV(63),
IAV(64), IAV(65), IAV(66), IAV(67), IAV(68), IAV(69), IAV(70), IAV(71),
IAV(72), IAV(73), IAV(74), IAV(75), IAV(76), IAV(77), IAV(78), IAV(79),
IAV(80), IAV(81), IAV(82), IAV(83), IAV(84), IAV(85), IAV(86), IAV(87),
IAV(88), IAV(89), IAV(90), IAV(91), IAV(92), IAV(93), IAV(94), IAV(95),
IAV(96), IAV(97), IAV(98), IAV(99), IAV(100), IAV(101), IAV(102), IAV(103),
IAV(104), IAV(105), IAV(106), IAV(107), IAV(108), IAV(109), IAV(110), IAV(111),
IAV(112), IAV(113), IAV(114), IAV(115), IAV(116), IAV(117), IAV(118), IAV(119),
IAV(120), IAV(121), IAV(122), IAV(123), IAV(124), IAV(125), IAV(126), IAV(127)
};
/* field-extraction macros */
#define first(b) ((b)->fd)
#define last(b) ((b)->bk)
/*
Indexing into bins
*/
#define bin_index(sz) \
(((((unsigned long)(sz)) >> 9) == 0) ? (((unsigned long)(sz)) >> 3): \
((((unsigned long)(sz)) >> 9) <= 4) ? 56 + (((unsigned long)(sz)) >> 6): \
((((unsigned long)(sz)) >> 9) <= 20) ? 91 + (((unsigned long)(sz)) >> 9): \
((((unsigned long)(sz)) >> 9) <= 84) ? 110 + (((unsigned long)(sz)) >> 12): \
((((unsigned long)(sz)) >> 9) <= 340) ? 119 + (((unsigned long)(sz)) >> 15): \
((((unsigned long)(sz)) >> 9) <= 1364) ? 124 + (((unsigned long)(sz)) >> 18): \
126)
/*
bins for chunks < 512 are all spaced 8 bytes apart, and hold
identically sized chunks. This is exploited in malloc.
*/
#define MAX_SMALLBIN 63
#define MAX_SMALLBIN_SIZE 512
#define SMALLBIN_WIDTH 8
#define smallbin_index(sz) (((unsigned long)(sz)) >> 3)
/*
Requests are `small' if both the corresponding and the next bin are small
*/
#define is_small_request(nb) (nb < MAX_SMALLBIN_SIZE - SMALLBIN_WIDTH)
/*
To help compensate for the large number of bins, a one-level index
structure is used for bin-by-bin searching. `binblocks' is a
one-word bitvector recording whether groups of BINBLOCKWIDTH bins
have any (possibly) non-empty bins, so they can be skipped over
all at once during during traversals. The bits are NOT always
cleared as soon as all bins in a block are empty, but instead only
when all are noticed to be empty during traversal in malloc.
*/
#define BINBLOCKWIDTH 4 /* bins per block */
#define binblocks (bin_at(0)->size) /* bitvector of nonempty blocks */
/* bin<->block macros */
#define idx2binblock(ix) ((unsigned)1 << (ix / BINBLOCKWIDTH))
#define mark_binblock(ii) (binblocks |= idx2binblock(ii))
#define clear_binblock(ii) (binblocks &= ~(idx2binblock(ii)))
/* Other static bookkeeping data */
/* variables holding tunable values */
static unsigned long trim_threshold = DEFAULT_TRIM_THRESHOLD;
static unsigned long top_pad = DEFAULT_TOP_PAD;
static unsigned int n_mmaps_max = DEFAULT_MMAP_MAX;
static unsigned long mmap_threshold = DEFAULT_MMAP_THRESHOLD;
/* The first value returned from sbrk */
static char* sbrk_base = (char*)(-1);
/* The maximum memory obtained from system via sbrk */
static unsigned long max_sbrked_mem = 0;
/* The maximum via either sbrk or mmap */
static unsigned long max_total_mem = 0;
/* internal working copy of mallinfo */
static struct mallinfo current_mallinfo = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
/* The total memory obtained from system via sbrk */
#define sbrked_mem (current_mallinfo.arena)
/* Tracking mmaps */
static unsigned int n_mmaps = 0;
static unsigned int max_n_mmaps = 0;
static unsigned long mmapped_mem = 0;
static unsigned long max_mmapped_mem = 0;
/*
Debugging support
*/
#if DEBUG
/*
These routines make a number of assertions about the states
of data structures that should be true at all times. If any
are not true, it's very likely that a user program has somehow
trashed memory. (It's also possible that there is a coding error
in malloc. In which case, please report it!)
*/
#if __STD_C
static void do_check_chunk(mchunkptr p)
#else
static void do_check_chunk(p) mchunkptr p;
#endif
{
INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
/* No checkable chunk is mmapped */
assert(!chunk_is_mmapped(p));
/* Check for legal address ... */
assert((char*)p >= sbrk_base);
if (p != top)
assert((char*)p + sz <= (char*)top);
else
assert((char*)p + sz <= sbrk_base + sbrked_mem);
}
#if __STD_C
static void do_check_free_chunk(mchunkptr p)
#else
static void do_check_free_chunk(p) mchunkptr p;
#endif
{
INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
mchunkptr next = chunk_at_offset(p, sz);
do_check_chunk(p);
/* Check whether it claims to be free ... */
assert(!inuse(p));
/* Unless a special marker, must have OK fields */
if ((long)sz >= (long)MINSIZE)
{
assert((sz & MALLOC_ALIGN_MASK) == 0);
assert(aligned_OK(chunk2mem(p)));
/* ... matching footer field */
assert(next->prev_size == sz);
/* ... and is fully consolidated */
assert(prev_inuse(p));
assert (next == top || inuse(next));
/* ... and has minimally sane links */
assert(p->fd->bk == p);
assert(p->bk->fd == p);
}
else /* markers are always of size SIZE_SZ */
assert(sz == SIZE_SZ);
}
#if __STD_C
static void do_check_inuse_chunk(mchunkptr p)
#else
static void do_check_inuse_chunk(p) mchunkptr p;
#endif
{
mchunkptr next = next_chunk(p);
do_check_chunk(p);
/* Check whether it claims to be in use ... */
assert(inuse(p));
/* ... and is surrounded by OK chunks.
Since more things can be checked with free chunks than inuse ones,
if an inuse chunk borders them and debug is on, it's worth doing them.
*/
if (!prev_inuse(p))
{
mchunkptr prv = prev_chunk(p);
assert(next_chunk(prv) == p);
do_check_free_chunk(prv);
}
if (next == top)
{
assert(prev_inuse(next));
assert(chunksize(next) >= MINSIZE);
}
else if (!inuse(next))
do_check_free_chunk(next);
}
#if __STD_C
static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
#else
static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
#endif
{
INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
long room = sz - s;
do_check_inuse_chunk(p);
/* Legal size ... */
assert((long)sz >= (long)MINSIZE);
assert((sz & MALLOC_ALIGN_MASK) == 0);
assert(room >= 0);
assert(room < (long)MINSIZE);
/* ... and alignment */
assert(aligned_OK(chunk2mem(p)));
/* ... and was allocated at front of an available chunk */
assert(prev_inuse(p));
}
#define check_free_chunk(P) do_check_free_chunk(P)
#define check_inuse_chunk(P) do_check_inuse_chunk(P)
#define check_chunk(P) do_check_chunk(P)
#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
#else
#define check_free_chunk(P)
#define check_inuse_chunk(P)
#define check_chunk(P)
#define check_malloced_chunk(P,N)
#endif
/*
Macro-based internal utilities
*/
/*
Linking chunks in bin lists.
Call these only with variables, not arbitrary expressions, as arguments.
*/
/*
Place chunk p of size s in its bin, in size order,
putting it ahead of others of same size.
*/
#define frontlink(P, S, IDX, BK, FD) \
{ \
if (S < MAX_SMALLBIN_SIZE) \
{ \
IDX = smallbin_index(S); \
mark_binblock(IDX); \
BK = bin_at(IDX); \
FD = BK->fd; \
P->bk = BK; \
P->fd = FD; \
FD->bk = BK->fd = P; \
} \
else \
{ \
IDX = bin_index(S); \
BK = bin_at(IDX); \
FD = BK->fd; \
if (FD == BK) mark_binblock(IDX); \
else \
{ \
while (FD != BK && S < chunksize(FD)) FD = FD->fd; \
BK = FD->bk; \
} \
P->bk = BK; \
P->fd = FD; \
FD->bk = BK->fd = P; \
} \
}
/* take a chunk off a list */
#define unlink(P, BK, FD) \
{ \
BK = P->bk; \
FD = P->fd; \
FD->bk = BK; \
BK->fd = FD; \
} \
/* Place p as the last remainder */
#define link_last_remainder(P) \
{ \
last_remainder->fd = last_remainder->bk = P; \
P->fd = P->bk = last_remainder; \
}
/* Clear the last_remainder bin */
#define clear_last_remainder \
(last_remainder->fd = last_remainder->bk = last_remainder)
/* Routines dealing with mmap(). */
#if HAVE_MMAP
#if __STD_C
static mchunkptr mmap_chunk(size_t size)
#else
static mchunkptr mmap_chunk(size) size_t size;
#endif
{
size_t page_mask = malloc_getpagesize - 1;
mchunkptr p;
#ifndef MAP_ANONYMOUS
static int fd = -1;
#endif
if(n_mmaps >= n_mmaps_max) return 0; /* too many regions */
/* For mmapped chunks, the overhead is one SIZE_SZ unit larger, because
* there is no following chunk whose prev_size field could be used.
*/
size = (size + SIZE_SZ + page_mask) & ~page_mask;
#ifdef MAP_ANONYMOUS
p = (mchunkptr)mmap(0, size, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
#else /* !MAP_ANONYMOUS */
if (fd < 0)
{
fd = open("/dev/zero", O_RDWR);
if(fd < 0) return 0;
}
p = (mchunkptr)mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
#endif
if(p == (mchunkptr)-1) return 0;
n_mmaps++;
if (n_mmaps > max_n_mmaps) max_n_mmaps = n_mmaps;
/* We demand that eight bytes into a page must be 8-byte aligned. */
assert(aligned_OK(chunk2mem(p)));
/* The offset to the start of the mmapped region is stored
* in the prev_size field of the chunk; normally it is zero,
* but that can be changed in memalign().
*/
p->prev_size = 0;
set_head(p, size|IS_MMAPPED);
mmapped_mem += size;
if ((unsigned long)mmapped_mem > (unsigned long)max_mmapped_mem)
max_mmapped_mem = mmapped_mem;
if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem)
max_total_mem = mmapped_mem + sbrked_mem;
return p;
}
#if __STD_C
static void munmap_chunk(mchunkptr p)
#else
static void munmap_chunk(p) mchunkptr p;
#endif
{
INTERNAL_SIZE_T size = chunksize(p);
int ret;
assert (chunk_is_mmapped(p));
assert(! ((char*)p >= sbrk_base && (char*)p < sbrk_base + sbrked_mem));
assert((n_mmaps > 0));
assert(((p->prev_size + size) & (malloc_getpagesize-1)) == 0);
n_mmaps--;
mmapped_mem -= (size + p->prev_size);
ret = munmap((char *)p - p->prev_size, size + p->prev_size);
/* munmap returns non-zero on failure */
assert(ret == 0);
}
#if HAVE_MREMAP
#if __STD_C
static mchunkptr mremap_chunk(mchunkptr p, size_t new_size)
#else
static mchunkptr mremap_chunk(p, new_size) mchunkptr p; size_t new_size;
#endif
{
size_t page_mask = malloc_getpagesize - 1;
INTERNAL_SIZE_T offset = p->prev_size;
INTERNAL_SIZE_T size = chunksize(p);
char *cp;
assert (chunk_is_mmapped(p));
assert(! ((char*)p >= sbrk_base && (char*)p < sbrk_base + sbrked_mem));
assert((n_mmaps > 0));
assert(((size + offset) & (malloc_getpagesize-1)) == 0);
/* Note the extra SIZE_SZ overhead as in mmap_chunk(). */
new_size = (new_size + offset + SIZE_SZ + page_mask) & ~page_mask;
cp = (char *)mremap((char *)p - offset, size + offset, new_size, 1);
if (cp == (char *)-1) return 0;
p = (mchunkptr)(cp + offset);
assert(aligned_OK(chunk2mem(p)));
assert((p->prev_size == offset));
set_head(p, (new_size - offset)|IS_MMAPPED);
mmapped_mem -= size + offset;
mmapped_mem += new_size;
if ((unsigned long)mmapped_mem > (unsigned long)max_mmapped_mem)
max_mmapped_mem = mmapped_mem;
if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem)
max_total_mem = mmapped_mem + sbrked_mem;
return p;
}
#endif /* HAVE_MREMAP */
#endif /* HAVE_MMAP */
/*
Extend the top-most chunk by obtaining memory from system.
Main interface to sbrk (but see also malloc_trim).
*/
#if __STD_C
static void malloc_extend_top(INTERNAL_SIZE_T nb)
#else
static void malloc_extend_top(nb) INTERNAL_SIZE_T nb;
#endif
{
char* brk; /* return value from sbrk */
INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of sbrked space */
INTERNAL_SIZE_T correction; /* bytes for 2nd sbrk call */
char* new_brk; /* return of 2nd sbrk call */
INTERNAL_SIZE_T top_size; /* new size of top chunk */
mchunkptr old_top = top; /* Record state of old top */
INTERNAL_SIZE_T old_top_size = chunksize(old_top);
char* old_end = (char*)(chunk_at_offset(old_top, old_top_size));
/* Pad request with top_pad plus minimal overhead */
INTERNAL_SIZE_T sbrk_size = nb + top_pad + MINSIZE;
unsigned long pagesz = malloc_getpagesize;
/* If not the first time through, round to preserve page boundary */
/* Otherwise, we need to correct to a page size below anyway. */
/* (We also correct below if an intervening foreign sbrk call.) */
if (sbrk_base != (char*)(-1))
sbrk_size = (sbrk_size + (pagesz - 1)) & ~(pagesz - 1);
brk = (char*)(MORECORE (sbrk_size));
/* Fail if sbrk failed or if a foreign sbrk call killed our space */
if (brk == (char*)(MORECORE_FAILURE) ||
(brk < old_end && old_top != initial_top))
return;
sbrked_mem += sbrk_size;
if (brk == old_end) /* can just add bytes to current top */
{
top_size = sbrk_size + old_top_size;
set_head(top, top_size | PREV_INUSE);
}
else
{
if (sbrk_base == (char*)(-1)) /* First time through. Record base */
sbrk_base = brk;
else /* Someone else called sbrk(). Count those bytes as sbrked_mem. */
sbrked_mem += brk - (char*)old_end;
/* Guarantee alignment of first new chunk made from this space */
front_misalign = (unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK;
if (front_misalign > 0)
{
correction = (MALLOC_ALIGNMENT) - front_misalign;
brk += correction;
}
else
correction = 0;
/* Guarantee the next brk will be at a page boundary */
correction += pagesz - ((unsigned long)(brk + sbrk_size) & (pagesz - 1));
/* Allocate correction */
new_brk = (char*)(MORECORE (correction));
if (new_brk == (char*)(MORECORE_FAILURE)) return;
sbrked_mem += correction;
top = (mchunkptr)brk;
top_size = new_brk - brk + correction;
set_head(top, top_size | PREV_INUSE);
if (old_top != initial_top)
{
/* There must have been an intervening foreign sbrk call. */
/* A double fencepost is necessary to prevent consolidation */
/* If not enough space to do this, then user did something very wrong */
if (old_top_size < MINSIZE)
{
set_head(top, PREV_INUSE); /* will force null return from malloc */
return;
}
/* Also keep size a multiple of MALLOC_ALIGNMENT */
old_top_size = (old_top_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
chunk_at_offset(old_top, old_top_size )->size =
SIZE_SZ|PREV_INUSE;
chunk_at_offset(old_top, old_top_size + SIZE_SZ)->size =
SIZE_SZ|PREV_INUSE;
set_head_size(old_top, old_top_size);
/* If possible, release the rest. */
if (old_top_size >= MINSIZE)
fREe(chunk2mem(old_top));
}
}
if ((unsigned long)sbrked_mem > (unsigned long)max_sbrked_mem)
max_sbrked_mem = sbrked_mem;
if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem)
max_total_mem = mmapped_mem + sbrked_mem;
/* We always land on a page boundary */
assert(((unsigned long)((char*)top + top_size) & (pagesz - 1)) == 0);
}
/* Main public routines */
/*
Malloc Algorthim:
The requested size is first converted into a usable form, `nb'.
This currently means to add 4 bytes overhead plus possibly more to
obtain 8-byte alignment and/or to obtain a size of at least
MINSIZE (currently 16 bytes), the smallest allocatable size.
(All fits are considered `exact' if they are within MINSIZE bytes.)
From there, the first successful of the following steps is taken:
1. The bin corresponding to the request size is scanned, and if
a chunk of exactly the right size is found, it is taken.
2. The most recently remaindered chunk is used if it is big
enough. This is a form of (roving) first fit, used only in
the absence of exact fits. Runs of consecutive requests use
the remainder of the chunk used for the previous such request
whenever possible. This limited use of a first-fit style
allocation strategy tends to give contiguous chunks
coextensive lifetimes, which improves locality and can reduce
fragmentation in the long run.
3. Other bins are scanned in increasing size order, using a
chunk big enough to fulfill the request, and splitting off
any remainder. This search is strictly by best-fit; i.e.,
the smallest (with ties going to approximately the least
recently used) chunk that fits is selected.
4. If large enough, the chunk bordering the end of memory
(`top') is split off. (This use of `top' is in accord with
the best-fit search rule. In effect, `top' is treated as
larger (and thus less well fitting) than any other available
chunk since it can be extended to be as large as necessary
(up to system limitations).
5. If the request size meets the mmap threshold and the
system supports mmap, and there are few enough currently
allocated mmapped regions, and a call to mmap succeeds,
the request is allocated via direct memory mapping.
6. Otherwise, the top of memory is extended by
obtaining more space from the system (normally using sbrk,
but definable to anything else via the MORECORE macro).
Memory is gathered from the system (in system page-sized
units) in a way that allows chunks obtained across different
sbrk calls to be consolidated, but does not require
contiguous memory. Thus, it should be safe to intersperse
mallocs with other sbrk calls.
All allocations are made from the the `lowest' part of any found
chunk. (The implementation invariant is that prev_inuse is
always true of any allocated chunk; i.e., that each allocated
chunk borders either a previously allocated and still in-use chunk,
or the base of its memory arena.)
*/
#if __STD_C
Void_t* mALLOc(size_t bytes)
#else
Void_t* mALLOc(bytes) size_t bytes;
#endif
{
mchunkptr victim; /* inspected/selected chunk */
INTERNAL_SIZE_T victim_size; /* its size */
int idx; /* index for bin traversal */
mbinptr bin; /* associated bin */
mchunkptr remainder; /* remainder from a split */
long remainder_size; /* its size */
int remainder_index; /* its bin index */
unsigned long block; /* block traverser bit */
int startidx; /* first bin of a traversed block */
mchunkptr fwd; /* misc temp for linking */
mchunkptr bck; /* misc temp for linking */
mbinptr q; /* misc temp */
INTERNAL_SIZE_T nb = request2size(bytes); /* padded request size; */
/* Check for exact match in a bin */
if (is_small_request(nb)) /* Faster version for small requests */
{
idx = smallbin_index(nb);
/* No traversal or size check necessary for small bins. */
q = bin_at(idx);
victim = last(q);
/* Also scan the next one, since it would have a remainder < MINSIZE */
if (victim == q)
{
q = next_bin(q);
victim = last(q);
}
if (victim != q)
{
victim_size = chunksize(victim);
unlink(victim, bck, fwd);
set_inuse_bit_at_offset(victim, victim_size);
check_malloced_chunk(victim, nb);
return chunk2mem(victim);
}
idx += 2; /* Set for bin scan below. We've already scanned 2 bins. */
}
else
{
idx = bin_index(nb);
bin = bin_at(idx);
for (victim = last(bin); victim != bin; victim = victim->bk)
{
victim_size = chunksize(victim);
remainder_size = victim_size - nb;
if (remainder_size >= (long)MINSIZE) /* too big */
{
--idx; /* adjust to rescan below after checking last remainder */
break;
}
else if (remainder_size >= 0) /* exact fit */
{
unlink(victim, bck, fwd);
set_inuse_bit_at_offset(victim, victim_size);
check_malloced_chunk(victim, nb);
return chunk2mem(victim);
}
}
++idx;
}
/* Try to use the last split-off remainder */
if ( (victim = last_remainder->fd) != last_remainder)
{
victim_size = chunksize(victim);
remainder_size = victim_size - nb;
if (remainder_size >= (long)MINSIZE) /* re-split */
{
remainder = chunk_at_offset(victim, nb);
set_head(victim, nb | PREV_INUSE);
link_last_remainder(remainder);
set_head(remainder, remainder_size | PREV_INUSE);
set_foot(remainder, remainder_size);
check_malloced_chunk(victim, nb);
return chunk2mem(victim);
}
clear_last_remainder;
if (remainder_size >= 0) /* exhaust */
{
set_inuse_bit_at_offset(victim, victim_size);
check_malloced_chunk(victim, nb);
return chunk2mem(victim);
}
/* Else place in bin */
frontlink(victim, victim_size, remainder_index, bck, fwd);
}
/*
If there are any possibly nonempty big-enough blocks,
search for best fitting chunk by scanning bins in blockwidth units.
*/
if ( (block = idx2binblock(idx)) <= binblocks)
{
/* Get to the first marked block */
if ( (block & binblocks) == 0)
{
/* force to an even block boundary */
idx = (idx & ~(BINBLOCKWIDTH - 1)) + BINBLOCKWIDTH;
block <<= 1;
while ((block & binblocks) == 0)
{
idx += BINBLOCKWIDTH;
block <<= 1;
}
}
/* For each possibly nonempty block ... */
for (;;)
{
startidx = idx; /* (track incomplete blocks) */
q = bin = bin_at(idx);
/* For each bin in this block ... */
do
{
/* Find and use first big enough chunk ... */
for (victim = last(bin); victim != bin; victim = victim->bk)
{
victim_size = chunksize(victim);
remainder_size = victim_size - nb;
if (remainder_size >= (long)MINSIZE) /* split */
{
remainder = chunk_at_offset(victim, nb);
set_head(victim, nb | PREV_INUSE);
unlink(victim, bck, fwd);
link_last_remainder(remainder);
set_head(remainder, remainder_size | PREV_INUSE);
set_foot(remainder, remainder_size);
check_malloced_chunk(victim, nb);
return chunk2mem(victim);
}
else if (remainder_size >= 0) /* take */
{
set_inuse_bit_at_offset(victim, victim_size);
unlink(victim, bck, fwd);
check_malloced_chunk(victim, nb);
return chunk2mem(victim);
}
}
bin = next_bin(bin);
} while ((++idx & (BINBLOCKWIDTH - 1)) != 0);
/* Clear out the block bit. */
do /* Possibly backtrack to try to clear a partial block */
{
if ((startidx & (BINBLOCKWIDTH - 1)) == 0)
{
binblocks &= ~block;
break;
}
--startidx;
q = prev_bin(q);
} while (first(q) == q);
/* Get to the next possibly nonempty block */
if ( (block <<= 1) <= binblocks && (block != 0) )
{
while ((block & binblocks) == 0)
{
idx += BINBLOCKWIDTH;
block <<= 1;
}
}
else
break;
}
}
/* Try to use top chunk */
/* Require that there be a remainder, ensuring top always exists */
if ( (remainder_size = chunksize(top) - nb) < (long)MINSIZE)
{
#if HAVE_MMAP
/* If big and would otherwise need to extend, try to use mmap instead */
if ((unsigned long)nb >= (unsigned long)mmap_threshold &&
(victim = mmap_chunk(nb)) != 0)
return chunk2mem(victim);
#endif
/* Try to extend */
malloc_extend_top(nb);
if ( (remainder_size = chunksize(top) - nb) < (long)MINSIZE)
return 0; /* propagate failure */
}
victim = top;
set_head(victim, nb | PREV_INUSE);
top = chunk_at_offset(victim, nb);
set_head(top, remainder_size | PREV_INUSE);
check_malloced_chunk(victim, nb);
return chunk2mem(victim);
}
/*
free() algorithm :
cases:
1. free(0) has no effect.
2. If the chunk was allocated via mmap, it is release via munmap().
3. If a returned chunk borders the current high end of memory,
it is consolidated into the top, and if the total unused
topmost memory exceeds the trim threshold, malloc_trim is
called.
4. Other chunks are consolidated as they arrive, and
placed in corresponding bins. (This includes the case of
consolidating with the current `last_remainder').
*/
#if __STD_C
void fREe(Void_t* mem)
#else
void fREe(mem) Void_t* mem;
#endif
{
mchunkptr p; /* chunk corresponding to mem */
INTERNAL_SIZE_T hd; /* its head field */
INTERNAL_SIZE_T sz; /* its size */
int idx; /* its bin index */
mchunkptr next; /* next contiguous chunk */
INTERNAL_SIZE_T nextsz; /* its size */
INTERNAL_SIZE_T prevsz; /* size of previous contiguous chunk */
mchunkptr bck; /* misc temp for linking */
mchunkptr fwd; /* misc temp for linking */
int islr; /* track whether merging with last_remainder */
if (mem == 0) /* free(0) has no effect */
return;
p = mem2chunk(mem);
hd = p->size;
#if HAVE_MMAP
if (hd & IS_MMAPPED) /* release mmapped memory. */
{
munmap_chunk(p);
return;
}
#endif
check_inuse_chunk(p);
sz = hd & ~PREV_INUSE;
next = chunk_at_offset(p, sz);
nextsz = chunksize(next);
if (next == top) /* merge with top */
{
sz += nextsz;
if (!(hd & PREV_INUSE)) /* consolidate backward */
{
prevsz = p->prev_size;
p = chunk_at_offset(p, -prevsz);
sz += prevsz;
unlink(p, bck, fwd);
}
set_head(p, sz | PREV_INUSE);
top = p;
if ((unsigned long)(sz) >= (unsigned long)trim_threshold)
malloc_trim(top_pad);
return;
}
set_head(next, nextsz); /* clear inuse bit */
islr = 0;
if (!(hd & PREV_INUSE)) /* consolidate backward */
{
prevsz = p->prev_size;
p = chunk_at_offset(p, -prevsz);
sz += prevsz;
if (p->fd == last_remainder) /* keep as last_remainder */
islr = 1;
else
unlink(p, bck, fwd);
}
if (!(inuse_bit_at_offset(next, nextsz))) /* consolidate forward */
{
sz += nextsz;
if (!islr && next->fd == last_remainder) /* re-insert last_remainder */
{
islr = 1;
link_last_remainder(p);
}
else
unlink(next, bck, fwd);
}
set_head(p, sz | PREV_INUSE);
set_foot(p, sz);
if (!islr)
frontlink(p, sz, idx, bck, fwd);
}
/*
Realloc algorithm:
Chunks that were obtained via mmap cannot be extended or shrunk
unless HAVE_MREMAP is defined, in which case mremap is used.
Otherwise, if their reallocation is for additional space, they are
copied. If for less, they are just left alone.
Otherwise, if the reallocation is for additional space, and the
chunk can be extended, it is, else a malloc-copy-free sequence is
taken. There are several different ways that a chunk could be
extended. All are tried:
* Extending forward into following adjacent free chunk.
* Shifting backwards, joining preceding adjacent space
* Both shifting backwards and extending forward.
* Extending into newly sbrked space
Unless the #define REALLOC_ZERO_BYTES_FREES is set, realloc with a
size argument of zero (re)allocates a minimum-sized chunk.
If the reallocation is for less space, and the new request is for
a `small' (<512 bytes) size, then the newly unused space is lopped
off and freed.
The old unix realloc convention of allowing the last-free'd chunk
to be used as an argument to realloc is no longer supported.
I don't know of any programs still relying on this feature,
and allowing it would also allow too many other incorrect
usages of realloc to be sensible.
*/
#if __STD_C
Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
#else
Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
#endif
{
INTERNAL_SIZE_T nb; /* padded request size */
mchunkptr oldp; /* chunk corresponding to oldmem */
INTERNAL_SIZE_T oldsize; /* its size */
mchunkptr newp; /* chunk to return */
INTERNAL_SIZE_T newsize; /* its size */
Void_t* newmem; /* corresponding user mem */
mchunkptr next; /* next contiguous chunk after oldp */
INTERNAL_SIZE_T nextsize; /* its size */
mchunkptr prev; /* previous contiguous chunk before oldp */
INTERNAL_SIZE_T prevsize; /* its size */
mchunkptr remainder; /* holds split off extra space from newp */
INTERNAL_SIZE_T remainder_size; /* its size */
mchunkptr bck; /* misc temp for linking */
mchunkptr fwd; /* misc temp for linking */
#ifdef REALLOC_ZERO_BYTES_FREES
if (bytes == 0) { fREe(oldmem); return 0; }
#endif
/* realloc of null is supposed to be same as malloc */
if (oldmem == 0) return mALLOc(bytes);
newp = oldp = mem2chunk(oldmem);
newsize = oldsize = chunksize(oldp);
nb = request2size(bytes);
#if HAVE_MMAP
if (chunk_is_mmapped(oldp))
{
#if HAVE_MREMAP
newp = mremap_chunk(oldp, nb);
if(newp) return chunk2mem(newp);
#endif
/* Note the extra SIZE_SZ overhead. */
if(oldsize - SIZE_SZ >= nb) return oldmem; /* do nothing */
/* Must alloc, copy, free. */
newmem = mALLOc(bytes);
if (newmem == 0) return 0; /* propagate failure */
MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
munmap_chunk(oldp);
return newmem;
}
#endif
check_inuse_chunk(oldp);
if ((long)(oldsize) < (long)(nb))
{
/* Try expanding forward */
next = chunk_at_offset(oldp, oldsize);
if (next == top || !inuse(next))
{
nextsize = chunksize(next);
/* Forward into top only if a remainder */
if (next == top)
{
if ((long)(nextsize + newsize) >= (long)(nb + MINSIZE))
{
newsize += nextsize;
top = chunk_at_offset(oldp, nb);
set_head(top, (newsize - nb) | PREV_INUSE);
set_head_size(oldp, nb);
return chunk2mem(oldp);
}
}
/* Forward into next chunk */
else if (((long)(nextsize + newsize) >= (long)(nb)))
{
unlink(next, bck, fwd);
newsize += nextsize;
goto split;
}
}
else
{
next = 0;
nextsize = 0;
}
/* Try shifting backwards. */
if (!prev_inuse(oldp))
{
prev = prev_chunk(oldp);
prevsize = chunksize(prev);
/* try forward + backward first to save a later consolidation */
if (next != 0)
{
/* into top */
if (next == top)
{
if ((long)(nextsize + prevsize + newsize) >= (long)(nb + MINSIZE))
{
unlink(prev, bck, fwd);
newp = prev;
newsize += prevsize + nextsize;
newmem = chunk2mem(newp);
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
top = chunk_at_offset(newp, nb);
set_head(top, (newsize - nb) | PREV_INUSE);
set_head_size(newp, nb);
return newmem;
}
}
/* into next chunk */
else if (((long)(nextsize + prevsize + newsize) >= (long)(nb)))
{
unlink(next, bck, fwd);
unlink(prev, bck, fwd);
newp = prev;
newsize += nextsize + prevsize;
newmem = chunk2mem(newp);
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
goto split;
}
}
/* backward only */
if (prev != 0 && (long)(prevsize + newsize) >= (long)nb)
{
unlink(prev, bck, fwd);
newp = prev;
newsize += prevsize;
newmem = chunk2mem(newp);
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
goto split;
}
}
/* Must allocate */
newmem = mALLOc (bytes);
if (newmem == 0) /* propagate failure */
return 0;
/* Avoid copy if newp is next chunk after oldp. */
/* (This can only happen when new chunk is sbrk'ed.) */
if ( (newp = mem2chunk(newmem)) == next_chunk(oldp))
{
newsize += chunksize(newp);
newp = oldp;
goto split;
}
/* Otherwise copy, free, and exit */
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
fREe(oldmem);
return newmem;
}
split: /* split off extra room in old or expanded chunk */
if (newsize - nb >= MINSIZE) /* split off remainder */
{
remainder = chunk_at_offset(newp, nb);
remainder_size = newsize - nb;
set_head_size(newp, nb);
set_head(remainder, remainder_size | PREV_INUSE);
set_inuse_bit_at_offset(remainder, remainder_size);
fREe(chunk2mem(remainder)); /* let free() deal with it */
}
else
{
set_head_size(newp, newsize);
set_inuse_bit_at_offset(newp, newsize);
}
check_inuse_chunk(newp);
return chunk2mem(newp);
}
/*
memalign algorithm:
memalign requests more than enough space from malloc, finds a spot
within that chunk that meets the alignment request, and then
possibly frees the leading and trailing space.
The alignment argument must be a power of two. This property is not
checked by memalign, so misuse may result in random runtime errors.
8-byte alignment is guaranteed by normal malloc calls, so don't
bother calling memalign with an argument of 8 or less.
Overreliance on memalign is a sure way to fragment space.
*/
#if __STD_C
Void_t* mEMALIGn(size_t alignment, size_t bytes)
#else
Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
#endif
{
INTERNAL_SIZE_T nb; /* padded request size */
char* m; /* memory returned by malloc call */
mchunkptr p; /* corresponding chunk */
char* brk; /* alignment point within p */
mchunkptr newp; /* chunk to return */
INTERNAL_SIZE_T newsize; /* its size */
INTERNAL_SIZE_T leadsize; /* leading space befor alignment point */
mchunkptr remainder; /* spare room at end to split off */
long remainder_size; /* its size */
/* If need less alignment than we give anyway, just relay to malloc */
if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
/* Otherwise, ensure that it is at least a minimum chunk size */
if (alignment < MINSIZE) alignment = MINSIZE;
/* Call malloc with worst case padding to hit alignment. */
nb = request2size(bytes);
m = (char*)(mALLOc(nb + alignment + MINSIZE));
if (m == 0) return 0; /* propagate failure */
p = mem2chunk(m);
if ((((unsigned long)(m)) % alignment) == 0) /* aligned */
{
#if HAVE_MMAP
if(chunk_is_mmapped(p))
return chunk2mem(p); /* nothing more to do */
#endif
}
else /* misaligned */
{
/*
Find an aligned spot inside chunk.
Since we need to give back leading space in a chunk of at
least MINSIZE, if the first calculation places us at
a spot with less than MINSIZE leader, we can move to the
next aligned spot -- we've allocated enough total room so that
this is always possible.
*/
brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) & -alignment);
if ((long)(brk - (char*)(p)) < MINSIZE) brk = brk + alignment;
newp = (mchunkptr)brk;
leadsize = brk - (char*)(p);
newsize = chunksize(p) - leadsize;
#if HAVE_MMAP
if(chunk_is_mmapped(p))
{
newp->prev_size = p->prev_size + leadsize;
set_head(newp, newsize|IS_MMAPPED);
return chunk2mem(newp);
}
#endif
/* give back leader, use the rest */
set_head(newp, newsize | PREV_INUSE);
set_inuse_bit_at_offset(newp, newsize);
set_head_size(p, leadsize);
fREe(chunk2mem(p));
p = newp;
assert (newsize >= nb && (((unsigned long)(chunk2mem(p))) % alignment) == 0);
}
/* Also give back spare room at the end */
remainder_size = chunksize(p) - nb;
if (remainder_size >= (long)MINSIZE)
{
remainder = chunk_at_offset(p, nb);
set_head(remainder, remainder_size | PREV_INUSE);
set_head_size(p, nb);
fREe(chunk2mem(remainder));
}
check_inuse_chunk(p);
return chunk2mem(p);
}
/*
valloc just invokes memalign with alignment argument equal
to the page size of the system (or as near to this as can
be figured out from all the includes/defines above.)
*/
#if __STD_C
Void_t* vALLOc(size_t bytes)
#else
Void_t* vALLOc(bytes) size_t bytes;
#endif
{
return mEMALIGn (malloc_getpagesize, bytes);
}
/*
pvalloc just invokes valloc for the nearest pagesize
that will accommodate request
*/
#if __STD_C
Void_t* pvALLOc(size_t bytes)
#else
Void_t* pvALLOc(bytes) size_t bytes;
#endif
{
size_t pagesize = malloc_getpagesize;
return mEMALIGn (pagesize, (bytes + pagesize - 1) & ~(pagesize - 1));
}
/*
calloc calls malloc, then zeroes out the allocated chunk.
*/
#if __STD_C
Void_t* cALLOc(size_t n, size_t elem_size)
#else
Void_t* cALLOc(n, elem_size) size_t n; size_t elem_size;
#endif
{
mchunkptr p;
INTERNAL_SIZE_T csz;
INTERNAL_SIZE_T sz = n * elem_size;
/* check if expand_top called, in which case don't need to clear */
#if MORECORE_CLEARS
mchunkptr oldtop = top;
INTERNAL_SIZE_T oldtopsize = chunksize(top);
#endif
Void_t* mem = mALLOc (sz);
if (mem == 0)
return 0;
else
{
p = mem2chunk(mem);
/* Two optional cases in which clearing not necessary */
#if HAVE_MMAP
if (chunk_is_mmapped(p)) return mem;
#endif
csz = chunksize(p);
#if MORECORE_CLEARS
if (p == oldtop && csz > oldtopsize)
{
/* clear only the bytes from non-freshly-sbrked memory */
csz = oldtopsize;
}
#endif
MALLOC_ZERO(mem, csz - SIZE_SZ);
return mem;
}
}
/*
cfree just calls free. It is needed/defined on some systems
that pair it with calloc, presumably for odd historical reasons.
*/
#if !defined(INTERNAL_LINUX_C_LIB) || !defined(__ELF__)
#if __STD_C
void cfree(Void_t *mem)
#else
void cfree(mem) Void_t *mem;
#endif
{
free(mem);
}
#endif
/*
Malloc_trim gives memory back to the system (via negative
arguments to sbrk) if there is unused memory at the `high' end of
the malloc pool. You can call this after freeing large blocks of
memory to potentially reduce the system-level memory requirements
of a program. However, it cannot guarantee to reduce memory. Under
some allocation patterns, some large free blocks of memory will be
locked between two used chunks, so they cannot be given back to
the system.
The `pad' argument to malloc_trim represents the amount of free
trailing space to leave untrimmed. If this argument is zero,
only the minimum amount of memory to maintain internal data
structures will be left (one page or less). Non-zero arguments
can be supplied to maintain enough trailing space to service
future expected allocations without having to re-obtain memory
from the system.
Malloc_trim returns 1 if it actually released any memory, else 0.
*/
#if __STD_C
int malloc_trim(size_t pad)
#else
int malloc_trim(pad) size_t pad;
#endif
{
long top_size; /* Amount of top-most memory */
long extra; /* Amount to release */
char* current_brk; /* address returned by pre-check sbrk call */
char* new_brk; /* address returned by negative sbrk call */
unsigned long pagesz = malloc_getpagesize;
top_size = chunksize(top);
extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
if (extra < (long)pagesz) /* Not enough memory to release */
return 0;
else
{
/* Test to make sure no one else called sbrk */
current_brk = (char*)(MORECORE (0));
if (current_brk != (char*)(top) + top_size)
return 0; /* Apparently we don't own memory; must fail */
else
{
new_brk = (char*)(MORECORE (-extra));
if (new_brk == (char*)(MORECORE_FAILURE)) /* sbrk failed? */
{
/* Try to figure out what we have */
current_brk = (char*)(MORECORE (0));
top_size = current_brk - (char*)top;
if (top_size >= (long)MINSIZE) /* if not, we are very very dead! */
{
sbrked_mem = current_brk - sbrk_base;
set_head(top, top_size | PREV_INUSE);
}
check_chunk(top);
return 0;
}
else
{
/* Success. Adjust top accordingly. */
set_head(top, (top_size - extra) | PREV_INUSE);
sbrked_mem -= extra;
check_chunk(top);
return 1;
}
}
}
}
/*
malloc_usable_size:
This routine tells you how many bytes you can actually use in an
allocated chunk, which may be more than you requested (although
often not). You can use this many bytes without worrying about
overwriting other allocated objects. Not a particularly great
programming practice, but still sometimes useful.
*/
#if __STD_C
size_t malloc_usable_size(Void_t* mem)
#else
size_t malloc_usable_size(mem) Void_t* mem;
#endif
{
mchunkptr p;
if (mem == 0)
return 0;
else
{
p = mem2chunk(mem);
if(!chunk_is_mmapped(p))
{
if (!inuse(p)) return 0;
check_inuse_chunk(p);
return chunksize(p) - SIZE_SZ;
}
return chunksize(p) - 2*SIZE_SZ;
}
}
/* Utility to update current_mallinfo for malloc_stats and mallinfo() */
static void malloc_update_mallinfo()
{
int i;
mbinptr b;
mchunkptr p;
#if DEBUG
mchunkptr q;
#endif
INTERNAL_SIZE_T avail = chunksize(top);
int navail = ((long)(avail) >= (long)MINSIZE)? 1 : 0;
for (i = 1; i < NAV; ++i)
{
b = bin_at(i);
for (p = last(b); p != b; p = p->bk)
{
#if DEBUG
check_free_chunk(p);
for (q = next_chunk(p);
q < top && inuse(q) && (long)(chunksize(q)) >= (long)MINSIZE;
q = next_chunk(q))
check_inuse_chunk(q);
#endif
avail += chunksize(p);
navail++;
}
}
current_mallinfo.ordblks = navail;
current_mallinfo.uordblks = sbrked_mem - avail;
current_mallinfo.fordblks = avail;
current_mallinfo.hblks = n_mmaps;
current_mallinfo.hblkhd = mmapped_mem;
current_mallinfo.keepcost = chunksize(top);
}
/*
malloc_stats:
Prints on stderr the amount of space obtain from the system (both
via sbrk and mmap), the maximum amount (which may be more than
current if malloc_trim and/or munmap got called), the maximum
number of simultaneous mmap regions used, and the current number
of bytes allocated via malloc (or realloc, etc) but not yet
freed. (Note that this is the number of bytes allocated, not the
number requested. It will be larger than the number requested
because of alignment and bookkeeping overhead.)
*/
void malloc_stats()
{
malloc_update_mallinfo();
fprintf(stderr, "max system bytes = %10u\n",
(unsigned int)(max_total_mem));
fprintf(stderr, "system bytes = %10u\n",
(unsigned int)(sbrked_mem + mmapped_mem));
fprintf(stderr, "in use bytes = %10u\n",
(unsigned int)(current_mallinfo.uordblks + mmapped_mem));
#if HAVE_MMAP
fprintf(stderr, "max mmap regions = %10u\n",
(unsigned int)max_n_mmaps);
#endif
}
/*
mallinfo returns a copy of updated current mallinfo.
*/
struct mallinfo mALLINFo()
{
malloc_update_mallinfo();
return current_mallinfo;
}
/*
mallopt:
mallopt is the general SVID/XPG interface to tunable parameters.
The format is to provide a (parameter-number, parameter-value) pair.
mallopt then sets the corresponding parameter to the argument
value if it can (i.e., so long as the value is meaningful),
and returns 1 if successful else 0.
See descriptions of tunable parameters above.
*/
#if __STD_C
int mALLOPt(int param_number, int value)
#else
int mALLOPt(param_number, value) int param_number; int value;
#endif
{
switch(param_number)
{
case M_TRIM_THRESHOLD:
trim_threshold = value; return 1;
case M_TOP_PAD:
top_pad = value; return 1;
case M_MMAP_THRESHOLD:
mmap_threshold = value; return 1;
case M_MMAP_MAX:
#if HAVE_MMAP
n_mmaps_max = value; return 1;
#else
if (value != 0) return 0; else n_mmaps_max = value; return 1;
#endif
default:
return 0;
}
}
/*
History:
V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
* Added pvalloc, as recommended by H.J. Liu
* Added 64bit pointer support mainly from Wolfram Gloger
* Added anonymously donated WIN32 sbrk emulation
* Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
* malloc_extend_top: fix mask error that caused wastage after
foreign sbrks
* Add linux mremap support code from HJ Liu
V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
* Integrated most documentation with the code.
* Add support for mmap, with help from
Wolfram Gloger ([email protected]).
* Use last_remainder in more cases.
* Pack bins using idea from [email protected]
* Use ordered bins instead of best-fit threshhold
* Eliminate block-local decls to simplify tracing and debugging.
* Support another case of realloc via move into top
* Fix error occuring when initial sbrk_base not word-aligned.
* Rely on page size for units instead of SBRK_UNIT to
avoid surprises about sbrk alignment conventions.
* Add mallinfo, mallopt. Thanks to Raymond Nijssen
([email protected]) for the suggestion.
* Add `pad' argument to malloc_trim and top_pad mallopt parameter.
* More precautions for cases where other routines call sbrk,
courtesy of Wolfram Gloger ([email protected]).
* Added macros etc., allowing use in linux libc from
H.J. Lu ([email protected])
* Inverted this history list
V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
* Re-tuned and fixed to behave more nicely with V2.6.0 changes.
* Removed all preallocation code since under current scheme
the work required to undo bad preallocations exceeds
the work saved in good cases for most test programs.
* No longer use return list or unconsolidated bins since
no scheme using them consistently outperforms those that don't
given above changes.
* Use best fit for very large chunks to prevent some worst-cases.
* Added some support for debugging
V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
* Removed footers when chunks are in use. Thanks to
Paul Wilson ([email protected]) for the suggestion.
V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
* Added malloc_trim, with help from Wolfram Gloger
([email protected]).
V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
* realloc: try to expand in both directions
* malloc: swap order of clean-bin strategy;
* realloc: only conditionally expand backwards
* Try not to scavenge used bins
* Use bin counts as a guide to preallocation
* Occasionally bin return list chunks in first scan
* Add a few optimizations from [email protected]
V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
* faster bin computation & slightly different binning
* merged all consolidations to one part of malloc proper
(eliminating old malloc_find_space & malloc_clean_bin)
* Scan 2 returns chunks (not just 1)
* Propagate failure in realloc if malloc returns 0
* Add stuff to allow compilation on non-ANSI compilers
from [email protected]
V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
* removed potential for odd address access in prev_chunk
* removed dependency on getpagesize.h
* misc cosmetics and a bit more internal documentation
* anticosmetics: mangled names in macros to evade debugger strangeness
* tested on sparc, hp-700, dec-mips, rs6000
with gcc & native cc (hp, dec only) allowing
Detlefs & Zorn comparison study (in SIGPLAN Notices.)
Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
* Based loosely on libg++-1.2X malloc. (It retains some of the overall
structure of old version, but most details differ.)
*/
|
the_stack_data/98451.c | #include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<errno.h>
#include<sys/ipc.h>
#include<semaphore.h>
#define N 5
time_t end_time;/*end time*/
sem_t mutex, customers, barbers; /*Three semaphors*/
int count = 0; /*The number of customers waiting for haircuts*/
void barber(void *arg);
void customer(void *arg);
int main(int argc, char *argv[])
{
pthread_t id1, id2;
int status = 0;
end_time = time(NULL) + 20;/*Barber Shop Hours is 20s*/
/*Semaphore initialization*/
sem_init(&mutex, 0, 1);
sem_init(&customers, 0, 0);
sem_init(&barbers, 0, 1);
/*Barber_thread initialization*/
status = pthread_create(&id1, NULL, (void *)barber, NULL);
if (status != 0)
perror("create barbers is failure!\n");
/*Customer_thread initialization*/
status = pthread_create(&id2, NULL, (void *)customer, NULL);
if (status != 0)
perror("create customers is failure!\n");
/*Customer_thread first blocked*/
pthread_join(id2, NULL);
pthread_join(id1, NULL);
exit(0);
}
void barber(void *arg)/*Barber Process*/
{
while (time(NULL) < end_time || count > 0)
{
sem_wait(&customers);/*P(customers)*/
sem_wait(&mutex);/*P(mutex)*/
count--;
printf("Barber:cut hair,count is:%d.\n", count);
sem_post(&mutex);/*V(mutex)*/
sem_post(&barbers);/*V(barbers)*/
sleep(3);
}
}
void customer(void *arg)/*Customers Process*/
{
while (time(NULL) < end_time)
{
sem_wait(&mutex);/*P(mutex)*/
if (count < N)
{
count++;
printf("Customer:add count,count is:%d\n", count);
sem_post(&mutex);/*V(mutex)*/
sem_post(&customer);/*V(customers)*/
sem_wait(&barbers);/*P(barbers)*/
}
else
/*V(mutex)*/
/*If the number is full of customers,just put the mutex lock let go*/
sem_post(&mutex);
sleep(1);
}
} |
the_stack_data/1247550.c | /*
Il processo principale crea un file "output.txt" di dimensione FILE_SIZE (all'inizio ogni byte del file deve avere valore 0)
#define FILE_SIZE (1024*1024)
#define N 4
è dato un semaforo senza nome: proc_sem
il processo principale crea N processi figli
i processi figli aspettano al semaforo proc_sem.
ogni volta che il processo i-mo riceve semaforo "verde", cerca il primo byte del file che abbia valore 0 e ci scrive il
valore ('A' + i). La scrittura su file è concorrente e quindi va gestita opportunamente (ad es. con un mutex).
se il processo i-mo non trova una posizione in cui poter scrivere il valore, allora termina.
il processo padre:
per (FILE_SIZE+N) volte, incrementa il semaforo proc_sem
aspetta i processi figli e poi termina.
risolvere il problema in due modi:
- soluzione A: usare le system call open(), lseek(), write()
- soluzione B: usare le system call open(), mmap()
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#define FILE_SIZE (1024*1024)
#define N 4
sem_t * proc_sem;
sem_t * mutex;
char * file_name_A = "/home/utente/output_A.txt";
char * file_name_B = "/home/utente/output_B.txt";
void create_file_set_size(char *file_name, unsigned int file_size);
void solution_A();
void solution_B();
void child_process_solution_A(int i);
#define CHECK_ERR(a,msg) {if ((a) == -1) { perror((msg)); exit(EXIT_FAILURE); } }
#define CHECK_ERR_MMAP(a,msg) {if ((a) == MAP_FAILED) { perror((msg)); exit(EXIT_FAILURE); } }
int main(int argc, char *argv[]) {
int res;
proc_sem = mmap(NULL, // NULL: è il kernel a scegliere l'indirizzo
sizeof(sem_t) * 2, // dimensione della memory map
PROT_READ | PROT_WRITE, // memory map leggibile e scrivibile
MAP_SHARED | MAP_ANONYMOUS, // memory map condivisibile con altri processi e senza file di appoggio
-1, 0); // offset nel file
CHECK_ERR_MMAP(proc_sem, "mmap")
mutex = proc_sem + 1;
res = sem_init(proc_sem,
1, // 1 => il semaforo è condiviso tra processi,
// 0 => il semaforo è condiviso tra threads del processo
0 // valore iniziale del semaforo
);
CHECK_ERR(res, "sem_init")
res = sem_init(mutex,
1, // 1 => il semaforo è condiviso tra processi,
// 0 => il semaforo è condiviso tra threads del processo
1 // valore iniziale del semaforo (se mettiamo 0 che succede?)
);
CHECK_ERR(res, "sem_init")
printf("Ora avvio la soluzione_A()...\n");
solution_A();
printf("\n\n");
printf("Ora avvio la soluzione_B()...\n");
solution_B();
res = sem_destroy(proc_sem);
CHECK_ERR(res, "sem_destroy")
res = sem_destroy(mutex);
CHECK_ERR(res, "sem_destroy")
return 0;
}
void solution_A() {
// usare le system call open(), lseek(), write()
create_file_set_size(file_name_A, FILE_SIZE);
for (int i = 0; i < N; i++) {
switch (fork()) {
case 0:
child_process_solution_A(i);
break;
case -1:
perror("fork()");
exit(EXIT_FAILURE);
default:
;
}
}
for (int i = 0; i < FILE_SIZE + N; i++) {
if (sem_post(proc_sem) == -1) {
perror("sem_post");
exit(EXIT_FAILURE);
}
}
while (wait(NULL) != -1) ;
printf("[parent] solution A - bye\n");
}
void solution_B() {
// usare le system call open(), mmap()
int fd;
char ch2write;
int exit_while = 0;
char * data;
char * ptr;
// quanti byte ha scritto il processo figlio
int write_counter = 0;
create_file_set_size(file_name_B, FILE_SIZE);
fd = open(file_name_B, O_RDWR);
// unica memory map condivisa tra i processi
data = mmap(NULL,
FILE_SIZE,
PROT_READ | PROT_WRITE, // memory map leggibile e scrivibile
MAP_SHARED,
fd,
0
);
if (data == MAP_FAILED) {
perror("mmap()");
exit(EXIT_FAILURE);
}
close(fd);
ptr = data;
// creiamo N processi
for (int i = 0; i < N; i++) {
switch (fork()) {
case 0:
ch2write = 'A' + i;
while (!exit_while) {
if (sem_wait(proc_sem) == -1) {
perror("sem_wait");
exit(EXIT_FAILURE);
}
if (sem_wait(mutex) == -1) {
perror("sem_wait");
exit(EXIT_FAILURE);
}
// cerchiamo la prossima posizione libera (ch == 0)
while (*ptr != 0 && ptr - data < FILE_SIZE)
ptr++;
if (ptr - data == FILE_SIZE) {
// non c'è una posizione libera in cui poter scrivere nel file
// usciamo dal while e terminiamo
printf("[child %d] EOF\n", i);
exit_while = 1;
} else {
*ptr = ch2write;
ptr++;
write_counter++;
}
if (sem_post(mutex) == -1) {
perror("sem_post");
exit(EXIT_FAILURE);
}
}
printf("[child %d] bye write_counter=%d\n", i, write_counter);
exit(EXIT_SUCCESS);
break;
case -1:
perror("fork()");
exit(EXIT_FAILURE);
default:
;
}
}
for (int i = 0; i < FILE_SIZE + N; i++) {
if (sem_post(proc_sem) == -1) {
perror("sem_post");
exit(EXIT_FAILURE);
}
}
while (wait(NULL) != -1) ;
printf("[parent] solution B - bye\n");
}
void create_file_set_size(char *file_name, unsigned int file_size) {
int res;
int fd = open(file_name,
O_CREAT | O_TRUNC | O_RDWR, // apriamo il file in lettura e scrittura
S_IRUSR | S_IWUSR // l'utente proprietario del file avrà i permessi di lettura e scrittura sul nuovo file
);
CHECK_ERR(fd, "open file")
res = ftruncate(fd, file_size);
CHECK_ERR(res, "ftruncate()")
close(fd);
}
void child_process_solution_A(int i) {
int fd;
int res;
char ch, ch2write;
off_t file_offset;
int exit_while = 0;
// quanti byte ha scritto il processo figlio
int write_counter = 0;
ch2write = 'A' + i;
fd = open(file_name_A, O_RDWR);
while (!exit_while) {
if (sem_wait(proc_sem) == -1) {
perror("sem_wait");
exit(EXIT_FAILURE);
}
if (sem_wait(mutex) == -1) {
perror("sem_wait");
exit(EXIT_FAILURE);
}
// cerchiamo la prossima posizione libera (ch == 0)
// read restituisce 0 in caso di EOF
while ((res = read(fd, &ch, 1)) > 0 && ch != 0) ;
// ok, abbiamo trovato una posizione dove scrivere il carattere
if (res == 1) {
// spostiamo il file offset indietro di -1
// perchè ogni read avanza di 1 byte
file_offset = lseek(fd, -1, SEEK_CUR);
res = write(fd, &ch2write, sizeof(ch2write));
CHECK_ERR(res, "write()")
write_counter++;
} else {
// non c'è una posizione libera in cui poter scrivere nel file
// usciamo dal while e terminiamo
printf("[child %d] EOF\n", i);
exit_while = 1;
}
if (sem_post(mutex) == -1) {
perror("sem_post");
exit(EXIT_FAILURE);
}
}
close(fd);
printf("[child %d] bye write_counter=%d\n", i, write_counter);
exit(EXIT_SUCCESS);
}
|
the_stack_data/1189865.c | #include <stdio.h>
int main(void) {
printf("Hello\tWorld!\n");
printf("Shu\tTamegai\n");
return 0;
}
|
the_stack_data/97447.c | #include <stdio.h>
#include <stdbool.h>
#define INPUT_ERROR 1
#define OK 0
#define MIN_SIZE 1
#define MAX_N 10
#define MAX_M 10
int get_matrix(int a[MAX_N][MAX_M], int *const n, int *const m)
{
printf("Input row's number:\n ");
if (scanf("%d", n) != 1 || MIN_SIZE > *n || MAX_N < *n)
return INPUT_ERROR;
printf("Input column's number:\n ");
if (scanf("%d", m) != 1 || MIN_SIZE > *m || MAX_N < *m)
return INPUT_ERROR;
printf("Input elements of matrix:\n");
for (int i = 0; i < *n; i++)
for (int j = 0; j < *m; j++)
if (scanf("%d", &a[i][j]) != 1)
return INPUT_ERROR;
return OK;
}
void get_array_of_symmetry(const int a[MAX_N][MAX_M], int n, int m, int * const arr)
{
bool symmetric;
for (int i = 0; i < n; i++)
{
symmetric = true;
for (int j = 0; j < (m + 1) / 2; j++)
if (a[i][j] != a[i][m - j - 1])
{
symmetric = false;
break;
}
*(arr + i) = symmetric;
}
}
void print_array(const int *const a, int n)
{
for (int const *i = a; i < a + n; i++)
printf("%d ", *i);
printf("\n");
}
int main(void)
{
int matrix[MAX_N][MAX_N];
int arr_of_symmetry[MAX_N];
int n, m;
if (get_matrix(matrix, &n, &m) != OK)
{
printf("Input error found\n");
return INPUT_ERROR;
}
get_array_of_symmetry((const int (*)[MAX_N]) matrix, n, m, arr_of_symmetry);
printf("\n");
print_array(arr_of_symmetry, n);
return OK;
} |
the_stack_data/76289.c | #include <string.h>
#define true 1
#define false 0
#define bool int
void reverse(char* str, int length) {
int start = 0;
int end = length - 1;
while (start < end) {
char Tmp = *(str + start);
*(str + start) = *(str + end);
*(str + end) = Tmp;
start++;
end--;
}
}
char* itoa_32(int num, char* str, int base) {
unsigned int unum = 0;
int i = 0;
bool isNegative = false;
if (num == 0) {
str[i++] = '0';
str[i] = '\0';
return str;
}
if (num < 0) {
if (base == 10) {
isNegative = true;
num = -num;
}
}
unum = (unsigned int)num;
while (unum != 0) {
unsigned int rem = unum % base;
str[i++] = (rem > 9) ? (rem - 10) + 'A' : rem + '0';
unum = unum / base;
}
if (isNegative)
str[i++] = '-';
str[i] = '\0';
reverse(str, i);
return str;
} |
the_stack_data/161082005.c | /* $OpenBSD: strncmp.c,v 1.6 1998/06/27 01:21:10 mickey Exp $ */
/*
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#if defined(LIBC_SCCS) && !defined(lint)
/*static char *sccsid = "from: @(#)strncmp.c 5.6 (Berkeley) 1/26/91";*/
static char *rcsid = "$OpenBSD: strncmp.c,v 1.6 1998/06/27 01:21:10 mickey Exp $";
#endif /* LIBC_SCCS and not lint */
#include <sys/types.h>
#if !defined(_KERNEL) && !defined(_STANDALONE)
#include <string.h>
#else
#include <lib/libkern/libkern.h>
#endif
int
strncmp(s1, s2, n)
register const char *s1, *s2;
register size_t n;
{
if (n == 0)
return (0);
do {
if (*s1 != *s2++)
return (*(const u_char *)s1 - *(const u_char *)--s2);
if (*s1++ == 0)
break;
} while (--n != 0);
return (0);
}
|
the_stack_data/167330550.c | #if __ARM32_ARCH__ >= 7
double sqrt(double x)
{
__asm__ __volatile__("vsqrt.f64 %P0, %P1" : "=w"(x) : "w"(x));
return x;
}
#endif
|
the_stack_data/50647.c | /* Copyright (C) 2011 by Valentin Ochs
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
/* Minor changes by Rich Felker for integration in musl, 2011-04-27. */
/* Smoothsort, an adaptive variant of Heapsort. Memory usage: O(1).
Run time: Worst case O(n log n), close to O(n) in the mostly-sorted case. */
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
static inline int a_ctz_64(uint64_t x)
{
static const char debruijn64[64] = {
0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28,
62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11,
63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
};
return debruijn64[(x&-(int64_t)x)*0x022fdd63cc95386dull >> 58];
}
#define ntz(x) a_ctz_64((x))
typedef int (*cmpfun)(const void *, const void *);
static inline int pntz(size_t p[2]) {
int r = ntz(p[0] - 1);
if(r != 0 || (r = 8*sizeof(size_t) + ntz(p[1])) != 8*sizeof(size_t)) {
return r;
}
return 0;
}
static void cycle(size_t width, unsigned char* ar[], int n)
{
unsigned char tmp[256];
size_t l;
int i;
if(n < 2) {
return;
}
ar[n] = tmp;
while(width) {
l = sizeof(tmp) < width ? sizeof(tmp) : width;
memcpy(ar[n], ar[0], l);
for(i = 0; i < n; i++) {
memcpy(ar[i], ar[i + 1], l);
ar[i] += l;
}
width -= l;
}
}
/* shl() and shr() need n > 0 */
static inline void shl(size_t p[2], int n)
{
if(n >= 8 * sizeof(size_t)) {
n -= 8 * sizeof(size_t);
p[1] = p[0];
p[0] = 0;
}
p[1] <<= n;
p[1] |= p[0] >> (sizeof(size_t) * 8 - n);
p[0] <<= n;
}
static inline void shr(size_t p[2], int n)
{
if(n >= 8 * sizeof(size_t)) {
n -= 8 * sizeof(size_t);
p[0] = p[1];
p[1] = 0;
}
p[0] >>= n;
p[0] |= p[1] << (sizeof(size_t) * 8 - n);
p[1] >>= n;
}
static void sift(unsigned char *head, size_t width, cmpfun cmp, int pshift, size_t lp[])
{
unsigned char *rt, *lf;
unsigned char *ar[14 * sizeof(size_t) + 1];
int i = 1;
ar[0] = head;
while(pshift > 1) {
rt = head - width;
lf = head - width - lp[pshift - 2];
if((*cmp)(ar[0], lf) >= 0 && (*cmp)(ar[0], rt) >= 0) {
break;
}
if((*cmp)(lf, rt) >= 0) {
ar[i++] = lf;
head = lf;
pshift -= 1;
} else {
ar[i++] = rt;
head = rt;
pshift -= 2;
}
}
cycle(width, ar, i);
}
static void trinkle(unsigned char *head, size_t width, cmpfun cmp, size_t pp[2], int pshift, int trusty, size_t lp[])
{
unsigned char *stepson,
*rt, *lf;
size_t p[2];
unsigned char *ar[14 * sizeof(size_t) + 1];
int i = 1;
int trail;
p[0] = pp[0];
p[1] = pp[1];
ar[0] = head;
while(p[0] != 1 || p[1] != 0) {
stepson = head - lp[pshift];
if((*cmp)(stepson, ar[0]) <= 0) {
break;
}
if(!trusty && pshift > 1) {
rt = head - width;
lf = head - width - lp[pshift - 2];
if((*cmp)(rt, stepson) >= 0 || (*cmp)(lf, stepson) >= 0) {
break;
}
}
ar[i++] = stepson;
head = stepson;
trail = pntz(p);
shr(p, trail);
pshift += trail;
trusty = 0;
}
if(!trusty) {
cycle(width, ar, i);
sift(head, width, cmp, pshift, lp);
}
}
void ssort(void *base, size_t nel, size_t width, cmpfun cmp)
{
size_t lp[12*sizeof(size_t)];
size_t i, size = width * nel;
unsigned char *head, *high;
size_t p[2] = {1, 0};
int pshift = 1;
int trail;
if (!size) return;
head = base;
high = head + size - width;
/* Precompute Leonardo numbers, scaled by element width */
for(lp[0]=lp[1]=width, i=2; (lp[i]=lp[i-2]+lp[i-1]+width) < size; i++);
while(head < high) {
if((p[0] & 3) == 3) {
sift(head, width, cmp, pshift, lp);
shr(p, 2);
pshift += 2;
} else {
if(lp[pshift - 1] >= (size_t)(high - head)) {
trinkle(head, width, cmp, p, pshift, 0, lp);
} else {
sift(head, width, cmp, pshift, lp);
}
if(pshift == 1) {
shl(p, 1);
pshift = 0;
} else {
shl(p, pshift - 1);
pshift = 1;
}
}
p[0] |= 1;
head += width;
}
trinkle(head, width, cmp, p, pshift, 0, lp);
while(pshift != 1 || p[0] != 1 || p[1] != 0) {
if(pshift <= 1) {
trail = pntz(p);
shr(p, trail);
pshift += trail;
} else {
shl(p, 2);
pshift -= 2;
p[0] ^= 7;
shr(p, 1);
trinkle(head - lp[pshift] - width, width, cmp, p, pshift + 1, 1, lp);
shl(p, 1);
p[0] |= 1;
trinkle(head - width, width, cmp, p, pshift, 1, lp);
}
head -= width;
}
}
|
the_stack_data/77101.c | #include <stdio.h>
#include <math.h>
// Item 1
void sphereVol(void){
float radius, volume;
printf("Digite o raio da esfera: ");
scanf("%f", &radius);
volume = (4.0/3.0) * M_PI * pow(radius, 3);
printf("O volume de uma esfera de raio %f cm é %f cm cúbicos.\n", radius, volume);
}
// Item 2
void gasPrice(void){
float gallonPrice, litrePrice, conversionTax;
float litresPerGallon = 3.7854;
printf("Digite o preço do galão de gasolina nos EUA: ");
scanf("%f", &gallonPrice);
printf("Digite taxa de conversão de Dólar para Real: ");
scanf("%f", &conversionTax);
litrePrice = (gallonPrice / litresPerGallon) * conversionTax;
printf("O preço do litro da gasolina em reais é de R$%.3f.\n", litrePrice);
}
// Item 3
void eventDuration(void){
unsigned long elapsedSeconds;
int hours, minutes, seconds;
printf("Entre com um tempo em segundos: .\n");
scanf("%d", &elapsedSeconds);
seconds = elapsedSeconds % 60;
hours = elapsedSeconds / 3600;
minutes = (elapsedSeconds % 3600) / 60;
printf("O evento durou %02d:%02d:%05.2f\n", hours, minutes, seconds);
}
// Item 4
void rad2dms(void){
float rad, deg, min, sec;
printf("Digite um ângulo em radianos: ");
scanf("%f", &rad);
deg = rad * (180 / M_PI);
min = (deg - (int)deg) * 60;
sec = (min - (int)min) * 60;
printf("%.4f radianos equivale a %d°%d\'%d\"\n", rad, (int)deg, (int)min, (int)sec);
}
// Item 5
void posNvel(void){
float s, s0, v, v0, t, a;
printf("Para um corpo em movimente, determine:\n Sua aceleração: a = ");
scanf("%f", &a);
printf(" sua posição inicial: S0 = ");
scanf("%f", &s0);
printf(" sua velocidade inicial: V0 = ");
scanf("%f", &v0);
printf(" o tempo de duração do movimento: t = ");
scanf("%f", &t);
s = s0 + (v0 * t) + (a * pow(t, 2)) / 2.0;
v = v0 + (a * t);
printf(" V = %.2f;\n S = %.2f\n", v, s);
}
// Item 6
void contaNotas(void){
int cedulas[7] = {100, 50, 20, 10, 5, 2, 1};
int valor, resultado;
printf("Entre com um valor inteiro de Reais: ");
scanf("%d", &valor);
printf("Este montante pode ser divido nas seguintes cédulas:\n");
for (int i = 0; i < 7; i++){
if (valor >= cedulas[i]){
resultado = valor / cedulas[i];
valor = valor % cedulas[i];
printf(" %d de R$%d;\n", resultado, cedulas[i]);
}
}
}
int main(void) {
char selection;
printf("\t\tComputadores Digitais 2\n\t\t\tLista 1\n\n");
printf("\t1 - Volume da esfera;\n");
printf("\t2 - Galão em Dólares para Litro em Reias;\n");
printf("\t3 - Tempo em segundos para formato hh:mm:ss.00;\n");
printf("\t4 - Radianos para Graus, minutos e segundos;\n");
printf("\t5 - Só vovó tem aquilo tudo quadrado e rachado no meio, vovô e vovó ainda tentam;\n");
printf("\t6 - Montante em Reais para cédulas;\n\n");
printf("Escolha um ítem da lista para ser executado: ");
scanf("%s", &selection);
switch(selection){
case '1':
sphereVol();
break;
case '2':
gasPrice();
break;
case '3':
eventDuration();
break;
case '4':
rad2dms();
break;
case '5':
posNvel();
break;
case '6':
contaNotas();
break;
default :
printf("Item não encontrado na lista!\n");
break;
}
}
|
the_stack_data/8740.c | #include <stdio.h>
int main() {
int loop, number;
int prime = 1;
number = 11;
for(loop = 2; loop < number; loop++) {
if((number % loop) == 0) {
prime = 0;
}
}
if (prime == 1)
printf("%d is prime number.", number);
else
printf("%d is not a prime number.", number);
return 0;
}
|
the_stack_data/212643928.c | #include <stdio.h>
#include <math.h>
int main(){
float pes,jarda,milha,polegada;
printf("Digite o valor de pés:\n");
scanf("%f%*c",&pes);
polegada=pes*12;
jarda=pes*3;
milha=pes*1.760;
printf("O valor de polegada é:%2.f\n",polegada);
printf("O valor de jarda é:%2.f\n",jarda);
printf("O valor de milha é:%2.f\n",milha);
return 0;
} |
the_stack_data/111078444.c | int a[1];
int *p = a;
void main () {
return;
}
|
the_stack_data/649639.c | #define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <errno.h>
#include <mqueue.h>
void display_usage(void) {
printf("usage: mqrm [options]\n"
"options:\n"
" -n <name> Message Queue name\n"
" -f Ignore errors\n");
exit(EXIT_FAILURE);
}
int main(int argc, char ** argv) {
char * name = NULL;
bool force = false;
for (int c = 0; (c = getopt(argc, argv, "n:fh?")) != -1;) {
switch (c) {
case 'n':
name = optarg;
break;
case 'f':
force = true;
break;
case 'h':
case '?':
display_usage();
break;
default:
abort();
}
}
if (!name) {
fprintf(stderr, "Missing Message Queue name.\n");
exit(EXIT_FAILURE);
}
int r = mq_unlink(name);
if (r == -1 && !force) {
if (errno == ENOENT) {
fprintf(stderr, "No queue with that name exists.\n");
exit(EXIT_FAILURE);
} else {
perror("mq_unlink");
exit(EXIT_FAILURE);
}
}
}
|
the_stack_data/146132.c | #include <stdio.h>
#define SIZE 3
int main()
{
void PrintA(int x[SIZE][SIZE]);
void Change(int y[SIZE][SIZE]);
int a[SIZE][SIZE];
int i, j;
for (i = 0; i < SIZE; i++)
{
for (j = 0; j < SIZE; j++)
{
printf("Plz input Line %d, Number %d: ", i + 1, j + 1);
scanf("%d", &a[i][j]);
}
}
printf("Array 1 is: \n");
PrintA(a);
Change(a);
printf("Array 2 is: \n");
PrintA(a);
return 0;
}
void PrintA(int x[SIZE][SIZE])
{
int i, j;
for (i = 0; i < SIZE; i++)
{
for (j = 0; j < SIZE; j++)
{
printf("%d ", x[i][j]);
if (j + 1 == SIZE)
printf("\n");
}
}
}
void Change(int y[SIZE][SIZE])
{
int s[SIZE][SIZE];
int i, j;
for (i = 0; i < SIZE; i++)
{
for (j = 0; j < SIZE; j++)
{
s[i][j] = y[i][j];
}
}
for (i = 0; i < SIZE; i++)
{
for (j = 0; j < SIZE; j++)
{
y[i][j] = s[j][i];
}
}
} |
the_stack_data/175142648.c |
/****************************************************************/
/* */
/* Ray Tracing Program for C */
/* */
/* Original Program by Ryoji Kawamichi */
/* Arranged for Chez Scheme by Motohico Nanano */
/* Arranged for Objective Caml by Y. Oiwa and E. Sumii */
/* Added diffuse ray tracer by Y.Ssugawara */
/* Arranged for C by K.Watanabe and H. Kobayashi */
/* */
/****************************************************************/
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
typedef struct {
double x, y, z;
} vec_t;
typedef struct {
double x, y, z, w;
} vec4_t;
typedef struct {
int tex, shape, surface;
bool isrot;
vec_t abc, xyz;
bool invert;
double surfparams[2];
vec_t color, rot123;
vec4_t ctbl;
} obj_t;
typedef struct {
vec_t rgb;
vec_t *isect_ps;
int *sids;
int *cdif;
vec_t *engy;
vec_t *r20p;
int gid;
vec_t *nvectors;
} pixel_t;
typedef struct {
vec_t vec;
double *cnst[120]; /* cnstの各要素は定数の配列(長さ4~6でオブジェクトの形による) */
} dvec_t;
typedef struct {
int sid;
dvec_t dv;
double br;
} refl_t;
/**************** グローバル変数の宣言 ****************/
/* オブジェクトの個数 */
int n_objects = 0;
/* オブジェクトのデータを入れるベクトル（最大60個）*/
obj_t objects[60];
/* Screen の中心座標 */
vec_t screen;
/* 視点の座標 */
vec_t viewpoint;
/* 光源方向ベクトル (単位ベクトル) */
vec_t light;
/* 鏡面ハイライト強度 (標準=255) */
double beam = 255.0;
/* AND ネットワークを保持 */
int *and_net[50];
/* OR ネットワークを保持 */
int **or_net;
/* 以下、交差判定ルーチンの返り値格納用 */
/* solver の交点 の t の値 */
double solver_dist = 0.0;
/* 交点の直方体表面での方向 */
int intsec_rectside = 0;
/* 発見した交点の最小の t */
double tmin = 1000000000.0;
/* 交点の座標 */
vec_t intersection_point;
/* 衝突したオブジェクト番号 */
int intersected_object_id = 0;
/* 法線ベクトル */
vec_t nvector;
/* 交点の色 */
vec_t texture_color;
/* 計算中の間接受光強度を保持 */
vec_t diffuse_ray;
/* スクリーン上の点の明るさ */
vec_t rgb;
/* 画像サイズ */
int image_size[2];
/* 画像の中心 = 画像サイズの半分 */
int image_center[2];
/* 3次元上のピクセル間隔 */
double scan_pitch;
/* judge_intersectionに与える光線始点 */
vec_t startp;
/* judge_intersection_fastに与える光線始点 */
vec_t startp_fast;
/* 画面上のx,y,z軸の3次元空間上の方向 */
vec_t screenx_dir;
vec_t screeny_dir;
vec_t screenz_dir;
/* 直接光追跡で使う光方向ベクトル */
vec_t ptrace_dirvec;
/* 間接光サンプリングに使う方向ベクトル */
dvec_t *dirvecs[5];
/* 光源光の前処理済み方向ベクトル */
dvec_t light_dirvec;
/* 鏡平面の反射情報 */
refl_t reflections[180];
/* reflectionsの有効な要素数 */
int n_reflections;
/******************************************************************************
Runtime
*****************************************************************************/
#define fneg(x) (-(x))
#define fispos(x) ((x) > 0.0)
#define fisneg(x) ((x) < 0.0)
#define fiszero(x) ((x) == 0.0)
#define fhalf(x) ((x) * 0.5)
#define fsqr(x) ((x) * (x))
#define int_of_double(f) ((int)(f))
#define float_of_int(i) ((double)(i))
int read_int() {
unsigned n = 0;
n += getchar();
n += getchar() << 8;
n += getchar() << 16;
n += getchar() << 24;
return n;
}
double read_float() {
union {unsigned i; float f;} u;
u.i = read_int();
return u.f;
}
void print_char(char c) {
printf("%c", c);
}
void print_int(int i) {
printf("%d", i);
}
/******************************************************************************
ユーティリティー
*****************************************************************************/
/* 符号 */
double sgn (double x) {
if (fiszero(x)) {
return 0.0;
} else if (fispos(x)) {
return 1.0;
} else {
return -1.0;
}
}
/* 条件付き符号反転 */
#define fneg_cond(cond, x) ((cond) ? (x) : fneg(x))
/******************************************************************************
ベクトル操作のためのプリミティブ
*****************************************************************************/
/* 値代入 */
#define vecset(v, a, b, c) \
do { \
(v)->x = a; \
(v)->y = b; \
(v)->z = c; \
} while(0)
/* 零初期化 */
#define vecbzero(v) \
((v)->x = (v)->y = (v)->z = 0.0)
/* 符号付正規化 ゼロ割チェック*/
void vecunit_sgn (vec_t *v, int inv) {
double l = sqrt (fsqr(v->x) + fsqr(v->y) + fsqr(v->z));
double il;
if (fiszero(l)) {
il = 1.0;
} else if (inv) {
il = -1.0 / l;
} else {
il = 1.0 / l;
}
v->x = v->x * il;
v->y = v->y * il;
v->z = v->z * il;
}
/* 内積 */
#define veciprod(v, w) \
((v)->x * (w)->x + (v)->y * (w)->y + (v)->z * (w)->z)
/* 内積 */
#define veciprod_d(v, w) \
((v)->vec.x * (w)->x + (v)->vec.y * (w)->y + (v)->vec.z * (w)->z)
/* 内積 引数形式が異なる版 */
#define veciprod2(v, w0, w1, w2) \
((v)->x * (w0) + (v)->y * (w1) + (v)->z * (w2))
/* 別なベクトルの定数倍を加算 */
#define vecaccum(dest, scale, v) \
do { \
(dest)->x += (scale) * (v)->x; \
(dest)->y += (scale) * (v)->y; \
(dest)->z += (scale) * (v)->z; \
} while(0)
/* ベクトルの和 */
#define vecadd(dest, v) \
do { \
(dest)->x += (v)->x; \
(dest)->y += (v)->y; \
(dest)->z += (v)->z; \
} while(0)
/* ベクトルを定数倍 */
#define vecscale(dest, scale) \
do { \
(dest)->x *= (scale); \
(dest)->y *= (scale); \
(dest)->z *= (scale); \
} while(0)
/* 他の２ベクトルの要素同士の積を計算し加算 */
#define vecaccumv(dest, v, w) \
do { \
(dest)->x += (v)->x * (w)->x; \
(dest)->y += (v)->y * (w)->y; \
(dest)->z += (v)->z * (w)->z; \
} while(0)
/******************************************************************************
オブジェクトデータ構造へのアクセス関数
*****************************************************************************/
/* テクスチャ種 0:無し 1:市松模様 2:縞模様 3:同心円模様 4:斑点*/
#define o_texturetype(m) ((m)->tex)
/* 物体の形状 0:直方体 1:平面 2:二次曲面 3:円錐 */
#define o_form(m) ((m)->shape)
/* 反射特性 0:拡散反射のみ 1:拡散＋非完全鏡面反射 2:拡散＋完全鏡面反射 */
#define o_reflectiontype(m) ((m)->surface)
/* 曲面の外側が真かどうかのフラグ true:外側が真 false:内側が真 */
#define o_isinvert(m) ((m)->invert)
/* 回転の有無 true:回転あり false:回転無し 2次曲面と円錐のみ有効 */
#define o_isrot(m) ((m)->isrot)
/* 物体形状の aパラメータ */
#define o_param_a(m) ((m)->abc.x)
/* 物体形状の bパラメータ */
#define o_param_b(m) ((m)->abc.y)
/* 物体形状の cパラメータ */
#define o_param_c(m) ((m)->abc.z)
/* 物体形状の abcパラメータ */
#define o_param_abc(m) (&(m)->abc)
/* 物体の中心x座標 */
#define o_param_x(m) ((m)->xyz.x)
/* 物体の中心y座標 */
#define o_param_y(m) ((m)->xyz.y)
/* 物体の中心z座標 */
#define o_param_z(m) ((m)->xyz.z)
/* 物体の拡散反射率 0.0 -- 1.0 */
#define o_diffuse(m) ((m)->surfparams[0])
/* 物体の不完全鏡面反射率 0.0 -- 1.0 */
#define o_hilight(m) ((m)->surfparams[1])
/* 物体色の R成分 */
#define o_color_red(m) ((m)->color.x)
/* 物体色の G成分 */
#define o_color_green(m) ((m)->color.y)
/* 物体色の B成分 */
#define o_color_blue(m) ((m)->color.z)
/* 物体の曲面方程式の y*z項の係数 2次曲面と円錐で、回転がある場合のみ */
#define o_param_r1(m) ((m)->rot123.x)
/* 物体の曲面方程式の x*z項の係数 2次曲面と円錐で、回転がある場合のみ */
#define o_param_r2(m) ((m)->rot123.y)
/* 物体の曲面方程式の x*y項の係数 2次曲面と円錐で、回転がある場合のみ */
#define o_param_r3(m) ((m)->rot123.z)
/* 光線の発射点をあらかじめ計算した場合の定数テーブル */
/*
0 -- 2 番目の要素: 物体の固有座標系に平行移動した光線始点
3番目の要素:
直方体→無効
平面→ abcベクトルとの内積
二次曲面、円錐→二次方程式の定数項
*/
#define o_param_ctbl(m) (&(m)->ctbl)
/******************************************************************************
Pixelデータのメンバアクセス関数群
*****************************************************************************/
/* 直接光追跡で得られたピクセルのRGB値 */
#define p_rgb(p) (&(p)->rgb)
/* 飛ばした光が物体と衝突した点の配列 */
#define p_intersection_points(p) ((p)->isect_ps)
/* 飛ばした光が衝突した物体面番号の配列 */
/* 物体面番号は オブジェクト番号 * 4 + (solverの返り値) */
#define p_surface_ids(p) ((p)->sids)
/* 間接受光を計算するか否かのフラグ */
#define p_calc_diffuse(p) ((p)->cdif)
/* 衝突点の間接受光エネルギーがピクセル輝度に与える寄与の大きさ */
#define p_energy(p) ((p)->engy)
/* 衝突点の間接受光エネルギーを光線本数を1/5に間引きして計算した値 */
#define p_received_ray_20percent(p) ((p)->r20p)
/* このピクセルのグループ ID */
/*
スクリーン座標 (x,y)の点のグループIDを (x+2*y) mod 5 と定める
結果、下図のような分け方になり、各点は上下左右4点と別なグループになる
0 1 2 3 4 0 1 2 3 4
2 3 4 0 1 2 3 4 0 1
4 0 1 2 3 4 0 1 2 3
1 2 3 4 0 1 2 3 4 0
*/
#define p_group_id(p) ((p)->gid)
/* グループIDをセットするアクセス関数 */
#define p_set_group_id(p, id) ((p)->gid = (id))
/* 各衝突点における法線ベクトル */
#define p_nvectors(p) ((p)->nvectors)
/******************************************************************************
前処理済み方向ベクトルのメンバアクセス関数
*****************************************************************************/
/* ベクトル */
#define d_vec(d) (&(d)->vec)
/* 各オブジェクトに対して作った solver 高速化用定数テーブル */
#define d_const(d) ((d)->cnst)
/******************************************************************************
平面鏡面体の反射情報
*****************************************************************************/
/* 面番号 オブジェクト番号*4 + (solverの返り値) */
#define r_surface_id(r) ((r)->sid)
/* 光源光の反射方向ベクトル(光と逆向き) */
#define r_dvec(r) &((r)->dv)
/* 物体の反射率 */
#define r_bright(r) ((r)->br)
/******************************************************************************
データ読み込みの関数群
*****************************************************************************/
/* ラジアン */
double rad (double x) {
return x * 0.017453293;
}
/**** 環境データの読み込み ****/
void read_screen_settings (void) {
double v1, cos_v1, sin_v1;
double v2, cos_v2, sin_v2;
screen.x = read_float();
screen.y = read_float();
screen.z = read_float();
v1 = rad(read_float());
v2 = rad(read_float());
cos_v1 = cos(v1);
sin_v1 = sin(v1);
cos_v2 = cos(v2);
sin_v2 = sin(v2);
screenz_dir.x = cos_v1 * sin_v2 * 200.0;
screenz_dir.y = sin_v1 * (-200.0);
screenz_dir.z = cos_v1 * cos_v2 * 200.0;
screenx_dir.x = cos_v2;
screenx_dir.y = 0.0;
screenx_dir.z = - sin_v2;
screeny_dir.x = - sin_v1 * sin_v2;
screeny_dir.y = - cos_v1;
screeny_dir.z = - sin_v1 * cos_v2;
viewpoint.x = screen.x - screenz_dir.x;
viewpoint.y = screen.y - screenz_dir.y;
viewpoint.z = screen.z - screenz_dir.z;
}
void read_light(void) {
int nl = read_int();
double l1 = rad(read_float());
double sl1 = sin(l1);
double l2 = rad(read_float());
double cl1 = cos(l1);
double sl2 = sin(l2);
double cl2 = cos(l2);
light.y = - sl1;
light.x = cl1 * sl2;
light.z = cl1 * cl2;
beam = read_float();
}
void rotate_quadratic_matrix(vec_t *abc, vec_t *rot) {
/* 回転行列の積 R(z)R(y)R(x) を計算する */
double cos_x = cos(rot->x);
double sin_x = sin(rot->x);
double cos_y = cos(rot->y);
double sin_y = sin(rot->y);
double cos_z = cos(rot->z);
double sin_z = sin(rot->z);
double m00 = cos_y * cos_z;
double m01 = sin_x * sin_y * cos_z - cos_x * sin_z;
double m02 = cos_x * sin_y * cos_z + sin_x * sin_z;
double m10 = cos_y * sin_z;
double m11 = sin_x * sin_y * sin_z + cos_x * cos_z;
double m12 = cos_x * sin_y * sin_z - sin_x * cos_z;
double m20 = - sin_y;
double m21 = sin_x * cos_y;
double m22 = cos_x * cos_y;
/* a, b, cの元の値をバックアップ */
double ao = abc->x;
double bo = abc->y;
double co = abc->z;
/* R^t * A * R を計算 */
/* X^2, Y^2, Z^2成分 */
abc->x = ao * fsqr(m00) + bo * fsqr(m10) + co * fsqr(m20);
abc->y = ao * fsqr(m01) + bo * fsqr(m11) + co * fsqr(m21);
abc->z = ao * fsqr(m02) + bo * fsqr(m12) + co * fsqr(m22);
/* 回転によって生じた XY, YZ, ZX成分 */
rot->x = 2.0 * (ao * m01 * m02 + bo * m11 * m12 + co * m21 * m22);
rot->y = 2.0 * (ao * m00 * m02 + bo * m10 * m12 + co * m20 * m22);
rot->z = 2.0 * (ao * m00 * m01 + bo * m10 * m11 + co * m20 * m21);
}
/**** オブジェクト1つのデータの読み込み ****/
bool read_nth_object(int n) {
int texture = read_int();
if (texture != -1) {
int form;
int refltype;
int isrot_p;
vec_t abc;
vec_t xyz;
int m_invert;
double reflparam[2];
vec_t color;
vec_t rotation;
bool m_invert2;
vec4_t ctbl;
form = read_int();
refltype = read_int();
isrot_p = read_int();
abc.x = read_float();
abc.y = read_float();
abc.z = read_float();
xyz.x = read_float();
xyz.y = read_float();
xyz.z = read_float();
m_invert = fisneg (read_float());
reflparam[0] = read_float(); /* diffuse */
reflparam[1] = read_float(); /* hilight */
color.x = read_float();
color.y = read_float();
color.z = read_float(); /* 15 */
if (isrot_p != 0) {
rotation.x = rad (read_float());
rotation.y = rad (read_float());
rotation.z = rad (read_float());
}
/* パラメータの正規化 */
/* 注: 下記正規化 (form = 2) 参照 */
m_invert2 = form == 2 ? true : m_invert;
if (form == 3) {
/* 2次曲面: X,Y,Z サイズから2次形式行列の対角成分へ */
double a = abc.x;
double b = abc.y;
double c = abc.z;
abc.x = (a == 0.0) ? 0.0 : (sgn(a) / fsqr(a)); /* X^2 成分 */
abc.y = (b == 0.0) ? 0.0 : (sgn(b) / fsqr(b)); /* Y^2 成分 */
abc.z = (c == 0.0) ? 0.0 : (sgn(c) / fsqr(c)); /* Z^2 成分 */
} else if (form == 2) {
/* 平面: 法線ベクトルを正規化, 極性を負に統一 */
vecunit_sgn(&abc, !m_invert);
}
/* 2次形式行列に回転変換を施す */
if (isrot_p != 0) {
rotate_quadratic_matrix(&abc, &rotation);
}
{
/* ここからあとは abc と rotation しか操作しない。*/
objects[n].tex = texture;
objects[n].shape = form;
objects[n].surface = refltype;
objects[n].isrot = isrot_p;
objects[n].abc = abc;
objects[n].xyz = xyz;
objects[n].invert = m_invert2;
/* reflection paramater */
objects[n].surfparams[0] = reflparam[0];
objects[n].surfparams[1] = reflparam[1];
objects[n].color = color;
objects[n].rot123 = rotation;
objects[n].ctbl = ctbl;
}
return true;
} else {
return false; /* データの終了 */
}
}
/**** 物体データ全体の読み込み ****/
void read_all_object() {
int i;
for(i = 0; i < 60; ++i) {
if(!read_nth_object(i)) {
n_objects = i;
return;
}
}
assert(false); /* failwith "too many objects" */
}
/**** AND, OR ネットワークの読み込み ****/
/* ネットワーク1つを読み込みベクトルにして返す */
int *read_net_item(int length) {
int item = read_int();
if (item == -1) {
int *ary = (int *) malloc(sizeof(int) * (length + 1));
memset(ary, -1, sizeof(int) * (length + 1));
return ary;
}else {
int *v = read_net_item(length + 1);
v[length] = item;
return v;
}
}
int **read_or_network(int length) {
int *net = read_net_item(0);
if (net[0] == -1) {
int **ary = (int **) malloc(sizeof(int*) * (length + 1));
int i;
for (i = 0; i < length + 1; ++i) {
ary[i] = net;
}
return ary;
} else {
int **v = read_or_network (length + 1);
v[length] = net;
return v;
}
}
void read_and_network (int n) {
int *net = read_net_item(0);
if (net[0] != -1) {
free(and_net[n]);
and_net[n] = net;
read_and_network(n + 1);
}
}
void read_parameter() {
read_screen_settings();
read_light();
read_all_object();
read_and_network(0);
or_net = read_or_network(0);
}
/******************************************************************************
直線とオブジェクトの交点を求める関数群
*****************************************************************************/
/* solver :
オブジェクト (の index) と、ベクトル L, P を受けとり、
直線 Lt + P と、オブジェクトとの交点を求める。
交点がない場合は 0 を、交点がある場合はそれ以外を返す。
この返り値は nvector で交点の法線ベクトルを求める際に必要。
(直方体の場合)
交点の座標は t の値として solver_dist に格納される。
*/
/* 直方体の指定された面に衝突するかどうか判定する */
/* i0 : 面に垂直な軸のindex X:0, Y:1, Z:2 i2,i3は他の2軸のindex */
bool solver_rect_surface(obj_t *m, vec_t *dirvec, double b0, double b1, double b2, int i0, int i1, int i2) {
double *dirvec_arr = (double *) dirvec;
if (dirvec_arr[i0] == 0.0) {
return false;
} else {
vec_t *abc = o_param_abc(m);
double *abc_arr = (double *) abc;
double d = fneg_cond(o_isinvert(m) ^ fisneg(dirvec_arr[i0]), abc_arr[i0]);
double d2 = (d - b0) / dirvec_arr[i0];
if ((fabs(d2 * dirvec_arr[i1] + b1)) < abc_arr[i1]) {
if ((fabs(d2 * dirvec_arr[i2] + b2)) < abc_arr[i2]) {
solver_dist = d2;
return true;
}else {
return false;
}
}
else {
return false;
}
}
}
/***** 直方体オブジェクトの場合 ****/
int solver_rect (obj_t *m, vec_t *dirvec, double b0, double b1, double b2) {
if (solver_rect_surface(m, dirvec, b0, b1, b2, 0, 1, 2)) {
return 1; /* YZ 平面 */
} else if (solver_rect_surface(m, dirvec, b1, b2, b0, 1, 2, 0)) {
return 2; /* ZX 平面 */
} else if (solver_rect_surface(m, dirvec, b2, b0, b1, 2, 0, 1)) {
return 3; /* XY 平面 */
} else {
return 0;
}
}
/* 平面オブジェクトの場合 */
int solver_surface(obj_t *m, vec_t *dirvec, double b0, double b1, double b2) {
/* 点と平面の符号つき距離 */
/* 平面は極性が負に統一されている */
vec_t *abc = o_param_abc(m);
double d = veciprod(dirvec, abc);
if (d > 0.0) {
solver_dist = fneg(veciprod2(abc, b0, b1, b2)) / d;
return 1;
} else {
return 0;
}
}
/* 3変数2次形式 v^t A v を計算 */
/* 回転が無い場合は対角部分のみ計算すれば良い */
double quadratic(obj_t *m, double v0, double v1, double v2) {
double diag_part =
fsqr(v0) * o_param_a(m) + fsqr(v1) * o_param_b(m) + fsqr(v2) * o_param_c(m);
if (o_isrot(m) == 0) {
return diag_part;
} else {
return diag_part
+ v1 * v2 * o_param_r1(m)
+ v2 * v0 * o_param_r2(m)
+ v0 * v1 * o_param_r3(m);
}
}
/* 3変数双1次形式 v^t A w を計算 */
/* 回転が無い場合は A の対角部分のみ計算すれば良い */
double bilinear(obj_t *m, double v0, double v1, double v2, double w0, double w1, double w2) {
double diag_part =
v0 * w0 * o_param_a(m)
+ v1 * w1 * o_param_b(m)
+ v2 * w2 * o_param_c(m);
if (o_isrot(m) == 0) {
return diag_part;
} else {
return diag_part + fhalf
((v2 * w1 + v1 * w2) * o_param_r1(m)
+ (v0 * w2 + v2 * w0) * o_param_r2(m)
+ (v0 * w1 + v1 * w0) * o_param_r3(m));
}
}
/* 2次曲面または円錐の場合 */
/* 2次形式で表現された曲面 x^t A x - (0 か 1) = 0 と 直線 base + dirvec*t の
交点を求める。曲線の方程式に x = base + dirvec*t を代入してtを求める。
つまり (base + dirvec*t)^t A (base + dirvec*t) - (0 か 1) = 0、
展開すると (dirvec^t A dirvec)*t^2 + 2*(dirvec^t A base)*t +
(base^t A base) - (0か1) = 0 、よってtに関する2次方程式を解けば良い。*/
int solver_second(obj_t *m, vec_t *dirvec, double b0, double b1, double b2) {
/* 解の公式 (-b' ± sqrt(b'^2 - a*c)) / a を使用(b' = b/2) */
/* a = dirvec^t A dirvec */
double aa = quadratic(m, dirvec->x, dirvec->y, dirvec->z);
if (aa == 0.0) {
return 0; /* 正確にはこの場合も1次方程式の解があるが、無視しても通常は大丈夫 */
} else {
/* b' = b/2 = dirvec^t A base */
double bb = bilinear(m, dirvec->x, dirvec->y, dirvec->z, b0, b1, b2);
/* c = base^t A base - (0か1) */
double cc0 = quadratic(m, b0, b1, b2);
double cc = o_form(m) == 3 ? cc0 - 1.0 : cc0;
/* 判別式 */
double d = bb * bb - aa * cc;
if (d > 0.0) {
double sd = sqrt(d);
double t1 = o_isinvert(m) ? sd : - sd;
solver_dist = (t1 - bb) / aa;
return 1;
} else {
return 0;
}
}
}
/**** solver のメインルーチン ****/
int solver(int index, vec_t *dirvec, vec_t *org) {
obj_t *m = &objects[index];
/* 直線の始点を物体の基準位置に合わせて平行移動 */
double b0 = org->x - o_param_x(m);
double b1 = org->y - o_param_y(m);
double b2 = org->z - o_param_z(m);
int m_shape = o_form(m);
/* 物体の種類に応じた補助関数を呼ぶ */
int ret;
if (m_shape == 1) {
ret = solver_rect(m, dirvec, b0, b1, b2); /* 直方体 */
} else if (m_shape == 2) {
ret = solver_surface(m, dirvec, b0, b1, b2); /* 平面 */
} else {
ret = solver_second(m, dirvec, b0, b1, b2); /* 2次曲面/円錐 */
}
return ret;
}
/******************************************************************************
solverのテーブル使用高速版
*****************************************************************************/
/*
通常版solver と同様、直線 start + t * dirvec と物体の交点を t の値として返す
t の値は solver_distに格納
solver_fast は、直線の方向ベクトル dirvec について作ったテーブルを使用
内部的に solver_rect_fast, solver_surface_fast, solver_second_fastを呼ぶ
solver_fast2 は、dirvecと直線の始点 start それぞれに作ったテーブルを使用
直方体についてはstartのテーブルによる高速化はできないので、solver_fastと
同じく solver_rect_fastを内部的に呼ぶ。それ以外の物体については
solver_surface_fast2またはsolver_second_fast2を内部的に呼ぶ
変数dconstは方向ベクトル、sconstは始点に関するテーブル
*/
/***** solver_rectのdirvecテーブル使用高速版 ******/
int solver_rect_fast(obj_t *m, vec_t *v, double *dconst, double b0, double b1, double b2) {
double d0 = (dconst[0] - b0) * dconst[1];
bool tmp0;
double d1 = (dconst[2] - b1) * dconst[3];
bool tmp_zx;
double d2 = (dconst[4] - b2) * dconst[5];
bool tmp_xy;
/* YZ平面との衝突判定 */
if (fabs (d0 * v->y + b1) < o_param_b(m)) {
if (fabs (d0 * v->z + b2) < o_param_c(m)) {
tmp0 = dconst[1] != 0.0;
}
else {
tmp0 = false;
}
}
else tmp0 = false;
if (tmp0 != false) {
solver_dist = d0;
return 1;
}
/* ZX平面との衝突判定 */
if (fabs (d1 * v->x + b0) < o_param_a(m)) {
if (fabs (d1 * v->z + b2) < o_param_c(m)) {
tmp_zx = dconst[3] != 0.0;
} else {
tmp_zx = false;
}
}
else tmp_zx = false;
if (tmp_zx != false) {
solver_dist = d1;
return 2;
}
/* XY平面との衝突判定 */
if (fabs (d2 * v->x + b0) < o_param_a(m)) {
if (fabs (d2 * v->y + b1) < o_param_b(m)) {
tmp_xy = dconst[5] != 0.0;
}
else tmp_xy = false;
}
else tmp_xy = false;
if (tmp_xy != false) {
solver_dist = d2;
return 3;
}
return 0;
}
/**** solver_surfaceのdirvecテーブル使用高速版 ******/
int solver_surface_fast(obj_t *m, double *dconst, double b0, double b1, double b2) {
if (fisneg(dconst[0])) {
solver_dist = dconst[1] * b0 + dconst[2] * b1 + dconst[3] * b2;
return 1;
} else {
return 0;
}
}
/**** solver_second のdirvecテーブル使用高速版 ******/
int solver_second_fast(obj_t *m, double *dconst, double b0, double b1, double b2) {
double aa = dconst[0];
if (fiszero(aa)) {
return 0;
} else {
double neg_bb = dconst[1] * b0 + dconst[2] * b1 + dconst[3] * b2;
double cc0 = quadratic(m, b0, b1, b2);
double cc = o_form(m) == 3 ? cc0 - 1.0 : cc0;
double d = fsqr(neg_bb) - aa * cc;
if (fispos(d)) {
if (o_isinvert(m)) {
solver_dist = (neg_bb + sqrt(d)) * dconst[4];
} else {
solver_dist = (neg_bb - sqrt(d)) * dconst[4];
}
return 1;
} else {
return 0;
}
}
}
/**** solver のdirvecテーブル使用高速版 *******/
int solver_fast(int index, dvec_t *dirvec, vec_t *org) {
obj_t *m = &objects[index];
double b0 = org->x - o_param_x(m);
double b1 = org->y - o_param_y(m);
double b2 = org->z - o_param_z(m);
double **dconsts = d_const(dirvec);
double *dconst = dconsts[index];
int m_shape = o_form(m);
int ret;
if (m_shape == 1) {
ret = solver_rect_fast(m, d_vec(dirvec), dconst, b0, b1, b2);
} else if (m_shape == 2) {
ret = solver_surface_fast(m, dconst, b0, b1, b2);
} else {
ret = solver_second_fast(m, dconst, b0, b1, b2);
}
return ret;
}
/* solver_surfaceのdirvec+startテーブル使用高速版 */
int solver_surface_fast2(obj_t *m, double *dconst, vec4_t *sconst, double b0, double b1, double b2) {
if (fisneg(dconst[0])) {
solver_dist = dconst[0] * sconst->w;
return 1;
} else {
return 0;
}
}
/* solver_secondのdirvec+startテーブル使用高速版 */
int solver_second_fast2(obj_t *m, double *dconst, vec4_t *sconst, double b0, double b1, double b2) {
double aa = dconst[0];
if (fiszero(aa)) {
return 0;
} else {
double neg_bb = dconst[1] * b0 + dconst[2] * b1 + dconst[3] * b2;
double cc = sconst->w;
double d = fsqr(neg_bb) - aa * cc;
if (fispos(d)) {
if (o_isinvert(m)) {
solver_dist = (neg_bb + sqrt(d)) * dconst[4];
} else {
solver_dist = (neg_bb - sqrt(d)) * dconst[4];
}
return 1;
} else {
return 0;
}
}
}
/* solverの、dirvec+startテーブル使用高速版 */
int solver_fast2(int index, dvec_t *dirvec) {
obj_t *m = &objects[index];
vec4_t *sconst = o_param_ctbl(m);
double b0 = sconst->x;
double b1 = sconst->y;
double b2 = sconst->z;
double **dconsts = d_const(dirvec);
double *dconst = dconsts[index];
int m_shape = o_form(m);
if (m_shape == 1) {
return solver_rect_fast(m, d_vec(dirvec), dconst, b0, b1, b2);
} else if (m_shape == 2) {
return solver_surface_fast2(m, dconst, sconst, b0, b1, b2);
} else {
return solver_second_fast2(m, dconst, sconst, b0, b1, b2);
}
}
/******************************************************************************
方向ベクトルの定数テーブルを計算する関数群
*****************************************************************************/
/* 直方体オブジェクトに対する前処理 */
double* setup_rect_table(vec_t *vec, obj_t *m) {
double *consts = (double*)malloc(6 * sizeof(double));
if (fiszero(vec->x)) { /* YZ平面 */
consts[1] = 0.0;
} else {
/* 面の X 座標 */
consts[0] = fneg_cond(o_isinvert(m)^fisneg(vec->x), o_param_a(m));
/* 方向ベクトルを何倍すればX方向に1進むか */
consts[1] = 1.0 / vec->x;
}
if (fiszero(vec->y)) { /* ZX平面 : YZ平面と同様*/
consts[3] = 0.0;
} else {
consts[2] = fneg_cond(o_isinvert(m)^fisneg(vec->y), o_param_b(m));
consts[3] = 1.0 / vec->y;
}
if (fiszero(vec->z)) { /* XY平面 : YZ平面と同様*/
consts[5] = 0.0;
} else {
consts[4] = fneg_cond(o_isinvert(m)^fisneg(vec->z), o_param_c(m));
consts[5] = 1.0 / vec->z;
}
return consts;
}
/* 平面オブジェクトに対する前処理 */
double* setup_surface_table(vec_t *vec, obj_t *m) {
double *consts = (double*)malloc(4 * sizeof(double));
double d = vec->x * o_param_a(m) + vec->y * o_param_b(m) + vec->z * o_param_c(m);
if (fispos(d)) {
/* 方向ベクトルを何倍すれば平面の垂直方向に 1 進むか */
consts[0] = -1.0 / d;
/* ある点の平面からの距離が方向ベクトル何個分かを導く3次一形式の係数 */
consts[1] = fneg(o_param_a(m) / d);
consts[2] = fneg(o_param_b(m) / d);
consts[3] = fneg(o_param_c(m) / d);
} else {
consts[0] = 0;
consts[1] = 0;
consts[2] = 0;
consts[3] = 0;
}
return consts;
}
/* 2次曲面に対する前処理 */
double* setup_second_table(vec_t *v, obj_t *m) {
double *consts = malloc(5 * sizeof(double));
double aa = quadratic(m, v->x, v->y, v->z);
double c1 = fneg(v->x * o_param_a(m));
double c2 = fneg(v->y * o_param_b(m));
double c3 = fneg(v->z * o_param_c(m));
consts[0] = aa; /* 2次方程式の a 係数 */
/* b' = dirvec^t A start だが、(dirvec^t A)の部分を計算しconst.(1:3)に格納。
b' を求めるにはこのベクトルとstartの内積を取れば良い。符号は逆にする */
if (o_isrot(m) != 0) {
consts[1] = c1 - fhalf(v->z * o_param_r2(m) + v->y * o_param_r3(m));
consts[2] = c2 - fhalf(v->z * o_param_r1(m) + v->x * o_param_r3(m));
consts[3] = c3 - fhalf(v->y * o_param_r1(m) + v->x * o_param_r2(m));
} else {
consts[1] = c1;
consts[2] = c2;
consts[3] = c3;
}
if (!fiszero(aa)) {
consts[4] = 1.0 / aa; /* a係数の逆数を求め、解の公式での割り算を消去 */
} else {
consts[4] = 0.0;
}
return consts;
}
/* 各オブジェクトについて補助関数を呼んでテーブルを作る */
void iter_setup_dirvec_constants (dvec_t *dirvec, int index) {
while (index >= 0) {
obj_t *m = &objects[index];
double **dconst = d_const(dirvec);
vec_t *v = d_vec(dirvec);
int m_shape = o_form(m);
if (m_shape == 1) { /* rect */
dconst[index] = setup_rect_table(v, m);
} else if (m_shape == 2) { /* surface */
dconst[index] = setup_surface_table(v, m);
} else { /* second */
dconst[index] = setup_second_table(v, m);
}
--index;
}
}
void setup_dirvec_constants(dvec_t *dirvec) {
iter_setup_dirvec_constants(dirvec, n_objects - 1);
}
/******************************************************************************
直線の始点に関するテーブルを各オブジェクトに対して計算する関数群
*****************************************************************************/
void setup_startp_constants(vec_t *p, int index) {
if (index >= 0) {
obj_t *obj = &objects[index];
vec4_t *sconst = o_param_ctbl(obj);
int m_shape = o_form(obj);
sconst->x = p->x - o_param_x(obj);
sconst->y = p->y - o_param_y(obj);
sconst->z = p->z - o_param_z(obj);
if (m_shape == 2) { /* surface */
sconst->w = veciprod2(o_param_abc(obj), sconst->x, sconst->y, sconst->z);
} else if (m_shape > 2) { /* second */
double cc0 = quadratic(obj, sconst->x, sconst->y, sconst->z);
sconst->w = (m_shape == 3 ? cc0 - 1.0 : cc0);
}
setup_startp_constants(p, index - 1);
}
}
void setup_startp(vec_t *p) {
startp_fast = *p;
setup_startp_constants(p, n_objects - 1);
}
/******************************************************************************
与えられた点がオブジェクトに含まれるかどうかを判定する関数群
*****************************************************************************/
/**** 点 q がオブジェクト m の外部かどうかを判定する ****/
/* 直方体 */
bool is_rect_outside(obj_t *m, double p0, double p1, double p2) {
bool b0 = fabs(p0) < o_param_a(m);
bool b1 = fabs(p1) < o_param_b(m);
bool b2 = fabs(p2) < o_param_c(m);
if(b0 && b1 && b2){
return o_isinvert(m);
} else {
return !o_isinvert(m);
}
}
/* 平面 */
bool is_plane_outside(obj_t *m, double p0, double p1, double p2) {
double w = veciprod2(o_param_abc(m), p0, p1, p2);
return !(o_isinvert(m) ^ fisneg(w));
}
/* 2次曲面 */
bool is_second_outside(obj_t *m, double p0, double p1, double p2) {
double w = quadratic(m, p0, p1, p2);
double w2 = (o_form(m) == 3 ? w - 1.0 : w);
return !(o_isinvert(m) ^ fisneg(w2));
}
/* 物体の中心座標に平行移動した上で、適切な補助関数を呼ぶ */
bool is_outside(obj_t *m, double q0, double q1, double q2) {
double p0 = q0 - o_param_x(m);
double p1 = q1 - o_param_y(m);
double p2 = q2 - o_param_z(m);
int m_shape = o_form(m);
if (m_shape == 1) {
return is_rect_outside(m, p0, p1, p2);
} else if (m_shape == 2) {
return is_plane_outside(m, p0, p1, p2);
} else {
return is_second_outside(m, p0, p1, p2);
}
}
bool check_all_inside(int ofs, int *iand, double q0, double q1, double q2) {
int head;
while((head = iand[ofs]) != -1){
if (is_outside(&objects[head], q0, q1, q2)) {
return false;
}
++ofs;
}
return true;
}
/******************************************************************************
衝突点が他の物体の影に入っているか否かを判定する関数群
*****************************************************************************/
/* 点 intersection_point から、光線ベクトルの方向に辿り、 */
/* 物体にぶつかる (=影にはいっている) か否かを判定する。*/
/**** AND ネットワーク iand の影内かどうかの判定 ****/
bool shadow_check_and_group(int iand_ofs, int *and_group) {
while (and_group[iand_ofs] != -1) {
int obj = and_group[iand_ofs];
int t0 = solver_fast(obj, &light_dirvec, &intersection_point);
double t0p = solver_dist;
if (t0 != 0 && t0p < -0.2) {
/* Q: 交点の候補。実際にすべてのオブジェクトに */
/* 入っているかどうかを調べる。*/
double t = t0p + 0.01;
double q0 = light.x * t + intersection_point.x;
double q1 = light.y * t + intersection_point.y;
double q2 = light.z * t + intersection_point.z;
if (check_all_inside(0, and_group, q0, q1, q2)) {
return true;
}
} else {
/* 交点がない場合: 極性が正(内側が真)の場合、 */
/* AND ネットの共通部分はその内部に含まれるため、*/
/* 交点はないことは自明。探索を打ち切る。 */
if (!o_isinvert(&objects[obj])) {
return false;
}
}
/* 次のオブジェクトから候補点を探す */
++iand_ofs;
}
return false;
}
/**** OR グループ or_group の影かどうかの判定 ****/
bool shadow_check_one_or_group(int ofs, int *or_group) {
int head;
while((head = or_group[ofs]) != -1) {
int *and_group = and_net[head];
bool shadow_p = shadow_check_and_group(0, and_group);
if (shadow_p) {
return true;
}
++ofs;
}
return false;
}
/**** OR グループの列のどれかの影に入っているかどうかの判定 ****/
bool shadow_check_one_or_matrix(int ofs, int **or_matrix) {
while(1) {
int *head = or_matrix[ofs];
int range_primitive = head[0];
bool test = false;
if (range_primitive == -1) { /* OR行列の終了マーク */
return false;
}
/* range primitive が無いか、またはrange_primitiveと交わる事を確認 */
if (range_primitive == 99) { /* range primitive が無い */
test = true;
} else {
int t = solver_fast(range_primitive, &light_dirvec, &intersection_point);
/* range primitive とぶつからなければ */
/* or group との交点はない */
test = (t != 0 && solver_dist < -0.1 && shadow_check_one_or_group(1, head));
}
if (test && shadow_check_one_or_group(1, head)) {
return true; /* 交点があるので、影に入る事が判明。探索終了 */
}
++ofs;
}
return false;
}
/******************************************************************************
光線と物体の交差判定
*****************************************************************************/
/**** あるANDネットワークが、レイトレースの方向に対し、****/
/**** 交点があるかどうかを調べる。 ****/
void solve_each_element(int iand_ofs, int *and_group, vec_t *dirvec) {
int iobj;
while ((iobj = and_group[iand_ofs]) != -1) {
int t0 = solver(iobj, dirvec, &startp);
if (t0 != 0) {
/* 交点がある時は、その交点が他の要素の中に含まれるかどうか調べる。*/
/* 今までの中で最小の t の値と比べる。*/
double t0p = solver_dist;
if (0.0 < t0p && t0p < tmin) {
double t = t0p + 0.01;
vec_t *v = dirvec;
double q0 = v->x * t + startp.x;
double q1 = v->y * t + startp.y;
double q2 = v->z * t + startp.z;
if (check_all_inside(0, and_group, q0, q1, q2)) {
tmin = t;
vecset(&intersection_point, q0, q1, q2);
intersected_object_id = iobj;
intsec_rectside = t0;
}
}
} else {
/* 交点がなく、しかもその物体は内側が真ならこれ以上交点はない */
if (!o_isinvert(&objects[iobj])) {
return;
}
}
++iand_ofs;
}
}
/**** 1つの OR-group について交点を調べる ****/
void solve_one_or_network(int ofs, int *or_group, vec_t *dirvec) {
int head;
while ((head = or_group[ofs]) != -1) {
int *and_group = and_net[head];
solve_each_element(0, and_group, dirvec);
++ofs;
}
}
/**** ORマトリクス全体について交点を調べる。****/
void trace_or_matrix(int ofs, int **or_network, vec_t *dirvec) {
while (1) { /* 全オブジェクト終了 */
int *head = or_network[ofs++];
int range_primitive = head[0];
if (range_primitive == -1) {
return;
}
if (range_primitive == 99) { /* range primitive なし */
solve_one_or_network(1, head, dirvec);
} else {
/* range primitive の衝突しなければ交点はない */
double t = solver(range_primitive, dirvec, &startp);
if (t != 0 && solver_dist < tmin) {
solve_one_or_network(1, head, dirvec);
}
}
}
}
/**** トレース本体 ****/
/* トレース開始点 ViewPoint と、その点からのスキャン方向ベクトル */
/* Vscan から、交点 crashed_point と衝突したオブジェクト */
/* crashed_object を返す。関数自体の返り値は交点の有無の真偽値。 */
bool judge_intersection(vec_t *dirvec) {
double t;
tmin = 1000000000.0;
trace_or_matrix(0, or_net, dirvec);
t = tmin;
if (-0.1 < t) {
return t < 100000000.0;
}
return false;
}
/******************************************************************************
光線と物体の交差判定 高速版
*****************************************************************************/
void solve_each_element_fast(int iand_ofs, int *and_group, dvec_t *dirvec) {
vec_t *vec = d_vec(dirvec);
int iobj;
while ((iobj = and_group[iand_ofs++]) != -1) {
int t0 = solver_fast2(iobj, dirvec);
if (t0 != 0) {
/* 交点がある時は、その交点が他の要素の中に含まれるかどうか調べる。*/
/* 今までの中で最小の t の値と比べる。*/
if (0.0 < solver_dist && solver_dist < tmin) {
double t = solver_dist + 0.01;
double q0 = vec->x * t + startp_fast.x;
double q1 = vec->y * t + startp_fast.y;
double q2 = vec->z * t + startp_fast.z;
if (check_all_inside(0, and_group, q0, q1, q2)) {
tmin = t;
vecset(&intersection_point, q0, q1, q2);
intersected_object_id = iobj;
intsec_rectside = t0;
}
}
} else if (!o_isinvert(&objects[iobj])) {
/* 交点がなく、しかもその物体は内側が真ならこれ以上交点はない */
return;
}
}
}
/**** 1つの OR-group について交点を調べる ****/
void solve_one_or_network_fast(int ofs, int *or_group, dvec_t *dirvec) {
int head;
while ((head = or_group[ofs++]) != -1) {
int *and_group = and_net[head];
solve_each_element_fast(0, and_group, dirvec);
}
}
/**** ORマトリクス全体について交点を調べる。****/
void trace_or_matrix_fast(int ofs, int **or_network, dvec_t *dirvec) {
while (1) {
int *head = or_network[ofs++];
int range_primitive = head[0];
if (range_primitive == -1) { /* 全オブジェクト終了 */
return;
}
if (range_primitive == 99) { /* range primitive なし */
solve_one_or_network_fast(1, head, dirvec);
} else {
/* range primitive の衝突しなければ交点はない */
double t = solver_fast2(range_primitive, dirvec);
if (t != 0 && solver_dist < tmin) {
solve_one_or_network_fast(1, head, dirvec);
}
}
}
}
/**** トレース本体 ****/
bool judge_intersection_fast(dvec_t *dirvec) {
double t;
tmin = 1000000000.0;
trace_or_matrix_fast(0, or_net, dirvec);
t = tmin;
if (-0.1 < t) {
return t < 100000000.0;
} else {
return false;
}
}
/******************************************************************************
物体と光の交差点の法線ベクトルを求める関数
*****************************************************************************/
/**** 交点から法線ベクトルを計算する ****/
/* 衝突したオブジェクトを求めた際の solver の返り値を */
/* 変数 intsec_rectside 経由で渡してやる必要がある。 */
/* nvector もグローバル。 */
void get_nvector_rect(vec_t *dirvec) {
int rectside = intsec_rectside;
/* solver の返り値はぶつかった面の方向を示す */
vecbzero(&nvector);
switch(rectside-1) {
case 0:
nvector.x = fneg(sgn(dirvec->x));
break;
case 1:
nvector.y = fneg(sgn(dirvec->y));
break;
case 2:
nvector.z = fneg(sgn(dirvec->z));
break;
default:
abort(); /* Error */
}
}
/* 平面 */
void get_nvector_plane(obj_t *m) {
/* m_invert は常に true のはず */
nvector.x = fneg(o_param_a(m));
nvector.y = fneg(o_param_b(m));
nvector.z = fneg(o_param_c(m));
}
/* 2次曲面 : grad x^t A x = 2 A x を正規化する */
void get_nvector_second(obj_t *m) {
double p0 = intersection_point.x - o_param_x(m);
double p1 = intersection_point.y - o_param_y(m);
double p2 = intersection_point.z - o_param_z(m);
double d0 = p0 * o_param_a(m);
double d1 = p1 * o_param_b(m);
double d2 = p2 * o_param_c(m);
if (o_isrot(m) == 0) {
nvector.x = d0;
nvector.y = d1;
nvector.z = d2;
} else {
nvector.x = d0 + fhalf(p1 * o_param_r3(m) + p2 * o_param_r2(m));
nvector.y = d1 + fhalf(p0 * o_param_r3(m) + p2 * o_param_r1(m));
nvector.z = d2 + fhalf(p0 * o_param_r2(m) + p1 * o_param_r1(m));
}
vecunit_sgn(&nvector, o_isinvert(m));
}
void get_nvector(obj_t *m, vec_t *dirvec) {
int m_shape = o_form(m);
if (m_shape == 1) {
get_nvector_rect(dirvec);
} else if (m_shape == 2) {
get_nvector_plane(m);
} else { /* 2次曲面 or 錐体 */
get_nvector_second(m);
}
}
/******************************************************************************
物体表面の色(色付き拡散反射率)を求める
*****************************************************************************/
/**** 交点上のテクスチャの色を計算する ****/
void utexture(obj_t *m, vec_t *p) {
int m_tex = o_texturetype(m);
/* 基本はオブジェクトの色 */
texture_color.x = o_color_red(m);
texture_color.y = o_color_green(m);
texture_color.z = o_color_blue(m);
if (m_tex == 1) {
/* zx方向のチェッカー模様 (G) */
double w1 = p->x - o_param_x(m);
double d1 = (floor(w1 * 0.05)) * 20.0;
double w3 = p->z - o_param_z(m);
double d2 = (floor(w3 * 0.05)) * 20.0;
int flag1 = (w1-d1 < 10.0);
int flag2 = (w3-d2 < 10.0);
if (flag1 ^ flag2) {
texture_color.y = 0.0;
} else {
texture_color.y = 255.0;
}
} else if (m_tex == 2) {
/* y軸方向のストライプ (R-G) */
double w2 = fsqr(sin(p->y * 0.25));
texture_color.x = 255.0 * w2;
texture_color.y = 255.0 * (1.0 - w2);
} else if (m_tex == 3) {
/* ZX面方向の同心円 (G-B) */
double w1 = p->x - o_param_x(m);
double w3 = p->z - o_param_z(m);
double w2 = sqrt (fsqr(w1) + fsqr(w3)) / 10.0;
double w4 = (w2 - floor(w2)) * 3.1415927;
double cws= fsqr(cos(w4));
texture_color.y = cws * 255.0;
texture_color.z = (1.0 - cws) * 255.0;
} else if (m_tex == 4) {
/* 球面上の斑点 (B) */
double w1 = (p->x - o_param_x(m)) * (sqrt(o_param_a(m)));
double w2 = (p->z - o_param_y(m)) * (sqrt(o_param_b(m)));
double w3 = (p->z - o_param_z(m)) * (sqrt(o_param_c(m)));
double w4 = fsqr(w1) + fsqr(w3);
double w5 = fabs(w3 / w1);
double w6 = fabs(w2 / w4);
double w7, w8, w9, w10, w11, w12;
if (fabs(w1) < 1.0e-4) {
w7 = 15.0; /* atan +infty = pi/2 */
} else {
w7 = (atan(w5) * 30.0) / 3.1415927;
}
if (fabs(w4) < 1.0e-4) {
w8 = 15.0; /* atan +infty = pi/2 */
} else {
w8 = (atan(w6) * 30.0) / 3.1415927;
}
w9 = w7 - floor(w7);
w10 = w8 - floor(w8);
w11 = 0.15 - fsqr(0.5 - w9) - fsqr(0.5 - w10);
w12 = (fisneg(w11)) ? 0.0 : w11;
texture_color.z = (255.0 * w12) / 0.3;
}
}
/******************************************************************************
衝突点に当たる光源の直接光と反射光を計算する関数群
*****************************************************************************/
/* 当たった光による拡散光と不完全鏡面反射光による寄与をRGB値に加算 */
void add_light(double bright, double hilight, double hilight_scale) {
/* 拡散光 */
if (fispos(bright)) {
vecaccum(&rgb, bright, &texture_color);
}
/* 不完全鏡面反射 cos ^4 モデル */
if (fispos(hilight)) {
double ihl = fsqr(fsqr(hilight)) * hilight_scale;
rgb.x += ihl;
rgb.y += ihl;
rgb.z += ihl;
}
}
/* 各物体による光源の反射光を計算する関数(直方体と平面のみ) */
void trace_reflections(int index, double diffuse, double hilight_scale, vec_t *dirvec) {
while (index >= 0) {
refl_t *rinfo = &reflections[index--]; /* 鏡平面の反射情報 */
dvec_t *dvec = r_dvec(rinfo); /* 反射光の方向ベクトル(光と逆向き */
/*反射光を逆にたどり、実際にその鏡面に当たれば、反射光が届く可能性有り */
if (judge_intersection_fast(dvec)) {
int surface_id = intersected_object_id * 4 + intsec_rectside;
if (surface_id == r_surface_id(rinfo)) {
/* 鏡面との衝突点が光源の影になっていなければ反射光は届く */
if (!shadow_check_one_or_matrix(0, or_net)) {
/* 届いた反射光による RGB成分への寄与を加算 */
double p = veciprod_d(dvec, &nvector);
double scale = r_bright(rinfo);
double bright = scale * diffuse * p;
double hilight = scale * veciprod(dirvec, d_vec(dvec));
add_light(bright, hilight, hilight_scale);
}
}
}
}
}
/******************************************************************************
直接光を追跡する
*****************************************************************************/
void trace_ray(int nref, double energy, vec_t *dirvec, pixel_t *pixel, double dist) {
if (nref <= 4) {
int *surface_ids = p_surface_ids(pixel);
if (judge_intersection(dirvec)) {
/* オブジェクトにぶつかった場合 */
int obj_id = intersected_object_id;
obj_t *obj = &objects[obj_id];
int m_surface = o_reflectiontype(obj);
double diffuse = o_diffuse(obj) * energy;
vec_t *intersection_points;
int *calc_diffuse;
double w, hilight_scale;
get_nvector(obj, dirvec); /* 法線ベクトルを get */
startp = intersection_point; /* 交差点を新たな光の発射点とする */
utexture(obj, &intersection_point); /*テクスチャを計算 */
/* pixel tupleに情報を格納する */
surface_ids[nref] = obj_id * 4 + intsec_rectside;
intersection_points = p_intersection_points(pixel);
intersection_points[nref] = intersection_point;
/* 拡散反射率が0.5以上の場合のみ間接光のサンプリングを行う */
calc_diffuse = p_calc_diffuse(pixel);
if (o_diffuse(obj) < 0.5) {
calc_diffuse[nref] = false;
} else {
vec_t *energya = p_energy(pixel);
vec_t *nvectors = p_nvectors(pixel);
calc_diffuse[nref] = true;
energya[nref] = texture_color;
vecscale(&energya[nref],
(1.0 / 256.0) * diffuse);
nvectors[nref] = nvector;
}
w = (-2.0) * veciprod(dirvec, &nvector);
vecaccum(dirvec, w, &nvector);
hilight_scale = energy * o_hilight(obj);
/* 光源光が直接届く場合、RGB成分にこれを加味する */
if (!(shadow_check_one_or_matrix(0, or_net))) {
double bright = fneg(veciprod(&nvector, &light)) * diffuse;
double hilight = fneg(veciprod(dirvec, &light));
add_light(bright, hilight, hilight_scale);
}
/* 光源光の反射光が無いか探す */
setup_startp(&intersection_point);
trace_reflections(n_reflections-1, diffuse, hilight_scale, dirvec);
/* 重みが 0.1より多く残っていたら、鏡面反射元を追跡する */
if (0.1 < energy) {
if (nref < 4) {
surface_ids[nref+1] = -1;
}
if (m_surface == 2) {
double energy2 = energy * (1.0 - o_diffuse(obj));
trace_ray(nref+1, energy2, dirvec, pixel, dist + tmin);
}
}
} else {
/* どの物体にも当たらなかった場合。光源からの光を加味 */
surface_ids[nref] = -1;
if (nref != 0) {
double hl = fneg(veciprod(dirvec, &light));
/* 90°を超える場合は0 (光なし) */
if (fispos(hl)) {
/* ハイライト強度は角度の cos^3 に比例 */
double ihl = fsqr(hl) * hl * energy * beam;
rgb.x += ihl;
rgb.y += ihl;
rgb.z += ihl;
}
}
}
}
}
/******************************************************************************
間接光を追跡する
*****************************************************************************/
/* ある点が特定の方向から受ける間接光の強さを計算する */
/* 間接光の方向ベクトル dirvecに関しては定数テーブルが作られており、衝突判定
が高速に行われる。物体に当たったら、その後の反射は追跡しない */
void trace_diffuse_ray(dvec_t *dirvec, double energy) {
/* どれかの物体に当たるか調べる */
if (judge_intersection_fast(dirvec)) {
obj_t *obj = &objects[intersected_object_id];
get_nvector(obj, d_vec(dirvec));
utexture(obj, &intersection_point);
/* その物体が放射する光の強さを求める。直接光源光のみを計算 */
if (!shadow_check_one_or_matrix(0, or_net)) {
double br = fneg(veciprod(&nvector, &light));
double bright = (fispos(br) ? br : 0.0);
vecaccum(&diffuse_ray,
energy * bright * o_diffuse(obj),
&texture_color);
}
}
}
/* あらかじめ決められた方向ベクトルの配列に対し、各ベクトルの方角から来る
間接光の強さをサンプリングして加算する */
void iter_trace_diffuse_rays(dvec_t *dirvec_group, vec_t *nvector, vec_t *org, int index) {
while (index >= 0) {
double p = veciprod(d_vec(&dirvec_group[index]), nvector);
/* 配列の 2n 番目と 2n+1 番目には互いに逆向の方向ベクトルが入っている
法線ベクトルと同じ向きの物を選んで使う */
if (fisneg(p)) {
trace_diffuse_ray(&dirvec_group[index+1], p / -150.0);
} else {
trace_diffuse_ray(&dirvec_group[index], p / 150.0);
}
index -= 2;
}
}
/* 与えられた方向ベクトルの集合に対し、その方向の間接光をサンプリングする */
void trace_diffuse_rays(dvec_t *dirvec_group, vec_t *nvector, vec_t *org) {
setup_startp(org);
/* 配列の 2n 番目と 2n+1 番目には互いに逆向の方向ベクトルが入っていて、
法線ベクトルと同じ向きの物のみサンプリングに使われる */
/* 全部で 120 / 2 = 60本のベクトルを追跡 */
iter_trace_diffuse_rays(dirvec_group, nvector, org, 118);
}
/* 半球方向の全部で300本のベクトルのうち、まだ追跡していない残りの240本の
ベクトルについて間接光追跡する。60本のベクトル追跡を4セット行う */
void trace_diffuse_ray_80percent(int group_id, vec_t *nvector, vec_t *org) {
int i;
for (i = 0; i <= 4; ++i) {
if (group_id != i) {
trace_diffuse_rays(dirvecs[i], nvector, org);
}
}
}
/* 上下左右4点の間接光追跡結果を使わず、300本全部のベクトルを追跡して間接光を
計算する。20%(60本)は追跡済なので、残り80%(240本)を追跡する */
void calc_diffuse_using_1point(pixel_t *pixel, int nref) {
vec_t *ray20p = p_received_ray_20percent(pixel);
vec_t *nvectors = p_nvectors(pixel);
vec_t *intersection_points = p_intersection_points(pixel);
vec_t *energya = p_energy(pixel);
diffuse_ray = ray20p[nref];
trace_diffuse_ray_80percent(p_group_id(pixel),
&nvectors[nref],
&intersection_points[nref]);
vecaccumv(&rgb, &energya[nref], &diffuse_ray);
}
/* 自分と上下左右4点の追跡結果を加算して間接光を求める。本来は 300 本の光を
追跡する必要があるが、5点加算するので1点あたり60本(20%)追跡するだけで済む */
void calc_diffuse_using_5points(int x, pixel_t *prev, pixel_t *cur, pixel_t *next, int nref) {
vec_t *r_up = p_received_ray_20percent(&prev[x]);
vec_t *r_left = p_received_ray_20percent(&cur[x-1]);
vec_t *r_center = p_received_ray_20percent(&cur[x]);
vec_t *r_right = p_received_ray_20percent(&cur[x+1]);
vec_t *r_down = p_received_ray_20percent(&next[x]);
vec_t *energya = p_energy(&cur[x]);
diffuse_ray = r_up[nref];
vecadd(&diffuse_ray, &r_left[nref]);
vecadd(&diffuse_ray, &r_center[nref]);
vecadd(&diffuse_ray, &r_right[nref]);
vecadd(&diffuse_ray, &r_down[nref]);
vecaccumv(&rgb, &energya[nref], &diffuse_ray);
}
/* 上下左右4点を使わずに直接光の各衝突点における間接受光を計算する */
void do_without_neighbors(pixel_t *pixel, int nref) {
while (nref <= 4) {
/* 衝突面番号が有効(非負)かチェック */
int *surface_ids = p_surface_ids(pixel), *calc_diffuse;
if (surface_ids[nref] < 0) {
return;
}
calc_diffuse = p_calc_diffuse(pixel);
if (calc_diffuse[nref]) {
calc_diffuse_using_1point(pixel, nref);
}
++nref;
}
}
/* 画像上で上下左右に点があるか(要するに、画像の端で無い事)を確認 */
bool neighbors_exist(int x, int y, pixel_t *next) {
if (0 < y && y+1 < image_size[1]) {
if (0 < x && x+1 < image_size[0]) {
return true;
}
}
return false;
}
int get_surface_id(pixel_t *pixel, int index) {
int *surface_ids = p_surface_ids(pixel);
return surface_ids[index];
}
/* 上下左右4点の直接光追跡の結果、自分と同じ面に衝突しているかをチェック
もし同じ面に衝突していれば、これら4点の結果を使うことで計算を省略出来る */
bool neighbors_are_available(int x, pixel_t *prev, pixel_t *cur, pixel_t *next, int nref) {
int sid_center = get_surface_id(&cur[x], nref);
if (get_surface_id(&prev[x], nref) == sid_center) {
if (get_surface_id(&next[x], nref) == sid_center) {
if (get_surface_id(&cur[x-1], nref) == sid_center) {
if (get_surface_id(&cur[x+1], nref) == sid_center) {
return true;
}
}
}
}
return false;
}
/* 直接光の各衝突点における間接受光の強さを、上下左右4点の結果を使用して計算
する。もし上下左右4点の計算結果を使えない場合は、その時点で
do_without_neighborsに切り替える */
void try_exploit_neighbors(int x, int y, pixel_t *prev, pixel_t *cur, pixel_t *next, int nref) {
pixel_t *pixel = &cur[x];
while (nref <= 4) {
int *calc_diffuse;
/* 衝突面番号が有効(非負)か */
if (get_surface_id(pixel, nref) < 0) {
return;
}
/* 周囲4点を補完に使えるか */
if (!neighbors_are_available(x, prev, cur, next, nref)) {
/* 周囲4点を補完に使えないので、これらを使わない方法に切り替える */
do_without_neighbors(&cur[x], nref);
return;
}
/* 間接受光を計算するフラグが立っていれば実際に計算する */
calc_diffuse = p_calc_diffuse(pixel);
if (calc_diffuse[nref]) {
calc_diffuse_using_5points(x, prev, cur, next, nref);
}
/* 次の反射衝突点へ */
++nref;
}
}
/******************************************************************************
PPMファイルの書き込み関数
*****************************************************************************/
void write_ppm_header() {
print_char(80); /* 'P' */
print_char(48 + 3); /* +6 if binary */ /* 48 = '0' */
print_char(10);
print_int(image_size[0]);
print_char(32);
print_int(image_size[1]);
print_char(32);
print_int(255);
print_char(10);
}
void write_rgb_element(double x) {
int ix = int_of_double(x);
int elem = ix;
if (ix > 255) {
elem = 255;
} else if (ix < 0) {
elem = 0;
}
print_int(elem);
}
void write_rgb() {
write_rgb_element(rgb.x); /* Red */
print_char(32);
write_rgb_element(rgb.y); /* Green */
print_char(32);
write_rgb_element(rgb.z); /* Blue */
print_char(10);
}
/******************************************************************************
あるラインの計算に必要な情報を集めるため次のラインの追跡を行っておく関数群
*****************************************************************************/
/* 間接光のサンプリングでは上下左右4点の結果を使うので、次のラインの計算を
行わないと最終的なピクセルの値を計算できない */
/* 間接光を 60本(20%)だけ計算しておく関数 */
void pretrace_diffuse_rays(pixel_t *pixel, int nref) {
while (nref <= 4 && get_surface_id(pixel, nref) >= 0) {
/* 間接光を計算するフラグが立っているか */
int *calc_diffuse = p_calc_diffuse(pixel);
if (calc_diffuse[nref]) {
int group_id = p_group_id(pixel);
vec_t *nvectors;
vec_t *intersection_points;
vec_t *ray20p;
vecbzero(&diffuse_ray);
/* 5つの方向ベクトル集合(各60本)から自分のグループIDに対応する物を
一つ選んで追跡 */
nvectors = p_nvectors(pixel);
intersection_points = p_intersection_points(pixel);
trace_diffuse_rays(dirvecs[group_id],
&nvectors[nref],
&intersection_points[nref]);
ray20p = p_received_ray_20percent(pixel);
ray20p[nref] = diffuse_ray;
}
++nref;
}
}
/* 各ピクセルに対して直接光追跡と間接受光の20%分の計算を行う */
void pretrace_pixels(pixel_t *line, int x, int group_id, double lc0, double lc1, double lc2) {
while (x >= 0) {
double xdisp = scan_pitch * float_of_int(x - image_center[0]);
ptrace_dirvec.x = xdisp * screenx_dir.x + lc0;
ptrace_dirvec.y = xdisp * screenx_dir.y + lc1;
ptrace_dirvec.z = xdisp * screenx_dir.z + lc2;
vecunit_sgn(&ptrace_dirvec, false);
vecbzero(&rgb);
startp = viewpoint;
/* 直接光追跡 */
trace_ray(0, 1.0, &ptrace_dirvec, &line[x], 0.0);
*p_rgb(&line[x]) = rgb;
p_set_group_id(&line[x], group_id);
/* 間接光の20%を追跡 */
pretrace_diffuse_rays(&line[x], 0);
--x;
group_id = (group_id + 1) % 5;
}
}
/* あるラインの各ピクセルに対し直接光追跡と間接受光20%分の計算をする */
void pretrace_line(pixel_t *line, int y, int group_id) {
double ydisp = scan_pitch * float_of_int(y - image_center[1]);
/* ラインの中心に向かうベクトルを計算 */
double lc0 = ydisp * screeny_dir.x + screenz_dir.x;
double lc1 = ydisp * screeny_dir.y + screenz_dir.y;
double lc2 = ydisp * screeny_dir.z + screenz_dir.z;
pretrace_pixels(line, image_size[0] - 1, group_id, lc0, lc1, lc2);
}
/******************************************************************************
直接光追跡と間接光20%追跡の結果から最終的なピクセル値を計算する関数
*****************************************************************************/
/* ピクセル値を計算 */
void scan_lines(pixel_t *prev, pixel_t *cur, pixel_t *next, int group_id) {
int y, x;
pixel_t *t;
for (y = 0; y < image_size[1]; ++y) {
if (y < image_size[1] - 1) {
pretrace_line(next, y + 1, group_id);
}
for (x = 0; x < image_size[0]; ++x) {
/* まず、直接光追跡で得られたRGB値を得る */
rgb = *p_rgb(&cur[x]);
/* 次に、直接光の各衝突点について、間接受光による寄与を加味する */
if (neighbors_exist(x, y, next)) {
try_exploit_neighbors(x, y, prev, cur, next, 0);
} else {
do_without_neighbors(&cur[x], 0);
}
/* 得られた値をPPMファイルに出力 */
write_rgb();
}
t = prev;
prev = cur;
cur = next;
next = t;
group_id += 2;
if(group_id >= 5) {
group_id -= 5;
}
}
}
/******************************************************************************
ピクセルの情報を格納するデータ構造の割り当て関数群
*****************************************************************************/
/* ピクセルを表すtupleを割り当て */
void create_pixel(pixel_t *pixel) {
vecbzero(&pixel->rgb);
pixel->isect_ps = calloc(sizeof(vec_t), 5);
pixel->sids = calloc(sizeof(int), 5);
pixel->cdif = calloc(sizeof(int), 5);
pixel->engy = calloc(sizeof(vec_t), 5);
pixel->r20p = calloc(sizeof(vec_t), 5);
pixel->gid = 0;
pixel->nvectors = calloc(sizeof(vec_t), 5);
}
/* 横方向1ライン分のピクセル配列を作る */
pixel_t *create_pixelline() {
pixel_t *line = calloc(sizeof(pixel_t), image_size[0]);
int i;
for (i = 0; i < image_size[0]; ++i) {
create_pixel(&line[i]);
}
return line;
}
/******************************************************************************
間接光のサンプリングにつかう方向ベクトル群を計算する関数群
*****************************************************************************/
/* ベクトル達が出来るだけ一様に分布するよう、600本の方向ベクトルの向きを定める
立方体上の各面に100本ずつ分布させ、さらに、100本が立方体上の面上で10 x 10 の
格子状に並ぶような配列を使う。この配列では方角によるベクトルの密度の差が
大きいので、これに補正を加えたものを最終的に用いる */
/* ベクトル達が出来るだけ球面状に一様に分布するよう座標を補正する */
double adjust_position(double h, double ratio) {
double l = sqrt(h * h + 0.1);
double tan_h = 1.0 / l;
double theta_h = atan(tan_h);
double tan_m = tan(theta_h * ratio);
return tan_m * l;
}
/* ベクトル達が出来るだけ球面状に一様に分布するような向きを計算する */
void calc_dirvec(int icount, double x, double y, double rx, double ry, int group_id, int index) {
double l, vx, vy, vz;
dvec_t *dgroup;
for(; icount < 5; ++icount) {
x = adjust_position(y, rx);
y = adjust_position(x, ry);
}
l = sqrt(fsqr(x) + fsqr(y) + 1.0);
vx = x / l;
vy = y / l;
vz = 1.0 / l;
/* 立方体的に対称に分布させる */
dgroup = dirvecs[group_id];
vecset(d_vec(&dgroup[index]), vx, vy, vz);
vecset(d_vec(&dgroup[index+40]), vx, vz, fneg(vy));
vecset(d_vec(&dgroup[index+80]), vz, fneg(vx), fneg(vy));
vecset(d_vec(&dgroup[index+1]), fneg(vx), fneg(vy), fneg(vz));
vecset(d_vec(&dgroup[index+41]), fneg(vx), fneg(vz), vy);
vecset(d_vec(&dgroup[index+81]), fneg(vz), vx, vy);
}
/* 立方体上の 10x10格子の行中の各ベクトルを計算する */
void calc_dirvecs(int col, double ry, int group_id, int index) {
while (col >= 0) {
double rx, rx2;
/* 左半分 */
rx = float_of_int(col) * 0.2 - 0.9; /* 列の座標 */
calc_dirvec(0, 0.0, 0.0, rx, ry, group_id, index);
/* 右半分 */
rx2 = float_of_int(col) * 0.2 + 0.1; /* 列の座標 */
calc_dirvec(0, 0.0, 0.0, rx2, ry, group_id, (index + 2));
--col;
if(++group_id >= 5) {
group_id -= 5;
}
}
}
/* 立方体上の10x10格子の各行に対しベクトルの向きを計算する */
void calc_dirvec_rows(int row, int group_id, int index) {
while (row >= 0) {
double ry = float_of_int(row) * 0.2 - 0.9; /* 行の座標 */
calc_dirvecs(4, ry, group_id, index); /* 一行分計算 */
--row;
group_id += 2;
if(group_id >= 5) {
group_id -= 5;
}
index += 4;
}
}
void create_dirvecs(int index) {
while(index >= 0) {
dirvecs[index] = calloc(120, sizeof(dvec_t));
--index;
}
}
/******************************************************************************
補助関数達を呼び出してdirvecの初期化を行う
*****************************************************************************/
void init_dirvec_constants(dvec_t vecset[], int index) {
while (index >= 0) {
setup_dirvec_constants(&vecset[index]);
--index;
}
}
void init_vecset_constants(int index) {
while (index >= 0) {
init_dirvec_constants(dirvecs[index], 119);
--index;
}
}
void init_dirvecs() {
create_dirvecs(4);
calc_dirvec_rows(9, 0, 0);
init_vecset_constants(4);
}
/******************************************************************************
完全鏡面反射成分を持つ物体の反射情報を初期化する
*****************************************************************************/
/* 反射平面を追加する */
void add_reflection(int index, int surface_id, double bright, double v0, double v1, double v2) {
dvec_t *dvec = &reflections[index].dv;
vecset(d_vec(dvec), v0, v1, v2); /* 反射光の向き */
setup_dirvec_constants(dvec);
reflections[index].sid = surface_id;
reflections[index].br = bright;
}
/* 直方体の各面について情報を追加する */
void setup_rect_reflection(int obj_id, obj_t *obj) {
int sid = obj_id * 4;
int nr = n_reflections;
double br = 1.0 - o_diffuse(obj);
double n0 = fneg(light.x);
double n1 = fneg(light.y);
double n2 = fneg(light.z);
add_reflection(nr, sid + 1, br, light.x, n1, n2);
add_reflection(nr + 1, sid + 2, br, n0, light.y, n2);
add_reflection(nr + 2, sid + 3, br, n0, n1, light.z);
n_reflections += 3;
}
/* 平面について情報を追加する */
void setup_surface_reflection(int obj_id, obj_t *obj) {
int sid = obj_id * 4 + 1;
int nr = n_reflections;
double br = 1.0 - o_diffuse(obj);
double p = veciprod(&light, o_param_abc(obj));
add_reflection(nr, sid, br,
2.0 * o_param_a(obj) * p - light.x,
2.0 * o_param_b(obj) * p - light.y,
2.0 * o_param_c(obj) * p - light.z);
n_reflections += 1;
}
/* 各オブジェクトに対し、反射する平面があればその情報を追加する */
void setup_reflections(int obj_id) {
if (obj_id >= 0) {
obj_t *obj = &objects[obj_id];
if (o_reflectiontype(obj) == 2) {
if (o_diffuse(obj) < 1.0) {
int m_shape = o_form(obj);
if (m_shape == 1) {
setup_rect_reflection(obj_id, obj);
} else if (m_shape == 2) {
setup_surface_reflection(obj_id, obj);
}
}
}
}
}
/*****************************************************************************
全体の制御
*****************************************************************************/
/* レイトレの各ステップを行う関数を順次呼び出す */
void rt (int size_x, int size_y) {
pixel_t *prev, *cur, *next;
image_size[0] = size_x;
image_size[1] = size_y;
image_center[0] = size_x / 2;
image_center[1] = size_y / 2;
scan_pitch = 128.0 / float_of_int(size_x);
prev = create_pixelline();
cur = create_pixelline();
next = create_pixelline();
read_parameter();
write_ppm_header();
init_dirvecs();
*d_vec(&light_dirvec) = light;
setup_dirvec_constants(&light_dirvec);
setup_reflections(n_objects - 1);
pretrace_line(cur, 0, 0);
scan_lines(prev, cur, next, 2);
}
int main(int argc, char *argv[]) {
int i;
char *p;
int size = 8;
if (argc > 1)
size = atoi(argv[1]);
for(i = 0; i < 50; ++i) {
and_net[i] = malloc(sizeof(int));
and_net[i][0] = -1;
}
p = malloc(64 * 1024);
if(p==0) {
fprintf(stderr, "malloc error\n");
exit(1);
}
p += 64 * 1024;
__asm("mov r1, [rbp - 12]\n");
__asm("mov rsp, [rbp - 8]\n");
__asm("mov rbp, [rbp - 8]\n");
__asm("push r1\n");
__asm("push r1\n");
__asm("call rt\n");
exit(0);
}
|
the_stack_data/20451137.c | /*
* $Id: tsce_ucode.c $
* Copyright: (c) 2018 Broadcom. All Rights Reserved. "Broadcom" refers to
* Broadcom Limited and/or its subsidiaries.
*
* Broadcom Switch Software License
*
* This license governs the use of the accompanying Broadcom software. Your
* use of the software indicates your acceptance of the terms and conditions
* of this license. If you do not agree to the terms and conditions of this
* license, do not use the software.
* 1. Definitions
* "Licensor" means any person or entity that distributes its Work.
* "Software" means the original work of authorship made available under
* this license.
* "Work" means the Software and any additions to or derivative works of
* the Software that are made available under this license.
* The terms "reproduce," "reproduction," "derivative works," and
* "distribution" have the meaning as provided under U.S. copyright law.
* Works, including the Software, are "made available" under this license
* by including in or with the Work either (a) a copyright notice
* referencing the applicability of this license to the Work, or (b) a copy
* of this license.
* 2. Grant of Copyright License
* Subject to the terms and conditions of this license, each Licensor
* grants to you a perpetual, worldwide, non-exclusive, and royalty-free
* copyright license to reproduce, prepare derivative works of, publicly
* display, publicly perform, sublicense and distribute its Work and any
* resulting derivative works in any form.
* 3. Grant of Patent License
* Subject to the terms and conditions of this license, each Licensor
* grants to you a perpetual, worldwide, non-exclusive, and royalty-free
* patent license to make, have made, use, offer to sell, sell, import, and
* otherwise transfer its Work, in whole or in part. This patent license
* applies only to the patent claims licensable by Licensor that would be
* infringed by Licensor's Work (or portion thereof) individually and
* excluding any combinations with any other materials or technology.
* If you institute patent litigation against any Licensor (including a
* cross-claim or counterclaim in a lawsuit) to enforce any patents that
* you allege are infringed by any Work, then your patent license from such
* Licensor to the Work shall terminate as of the date such litigation is
* filed.
* 4. Redistribution
* You may reproduce or distribute the Work only if (a) you do so under
* this License, (b) you include a complete copy of this License with your
* distribution, and (c) you retain without modification any copyright,
* patent, trademark, or attribution notices that are present in the Work.
* 5. Derivative Works
* You may specify that additional or different terms apply to the use,
* reproduction, and distribution of your derivative works of the Work
* ("Your Terms") only if (a) Your Terms provide that the limitations of
* Section 7 apply to your derivative works, and (b) you identify the
* specific derivative works that are subject to Your Terms.
* Notwithstanding Your Terms, this license (including the redistribution
* requirements in Section 4) will continue to apply to the Work itself.
* 6. Trademarks
* This license does not grant any rights to use any Licensor's or its
* affiliates' names, logos, or trademarks, except as necessary to
* reproduce the notices described in this license.
* 7. Limitations
* Platform. The Work and any derivative works thereof may only be used, or
* intended for use, with a Broadcom switch integrated circuit.
* No Reverse Engineering. You will not use the Work to disassemble,
* reverse engineer, decompile, or attempt to ascertain the underlying
* technology of a Broadcom switch integrated circuit.
* 8. Termination
* If you violate any term of this license, then your rights under this
* license (including the license grants of Sections 2 and 3) will
* terminate immediately.
* 9. Disclaimer of Warranty
* THE WORK IS PROVIDED "AS IS" WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR
* NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER
* THIS LICENSE. SOME STATES' CONSUMER LAWS DO NOT ALLOW EXCLUSION OF AN
* IMPLIED WARRANTY, SO THIS DISCLAIMER MAY NOT APPLY TO YOU.
* 10. Limitation of Liability
* EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL
* THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE
* SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
* INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
* OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK
* (INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION,
* LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER
* COMMERCIAL DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGES.
*
*
* All Rights Reserved.$
*/
#define EAGLE_TSC_UCODE_IMAGE_VERSION "D10F_13" /* matches the version number from microcode */
#define EAGLE_TSC_UCODE_IMAGE_SIZE 31744
#define EAGLE_TSC_UCODE_IMAGE_CRC 0x6105
unsigned short tsce_ucode_ver = 0xD10F;
unsigned short tsce_ucode_crc = EAGLE_TSC_UCODE_IMAGE_CRC;
unsigned short tsce_ucode_len = EAGLE_TSC_UCODE_IMAGE_SIZE;
unsigned char tsce_ucode[] = {
0x75, 0x81, 0x38, 0x02, 0x6f, 0xc0, 0xe5, 0x38, 0x70, 0x31, 0x12, 0x5d,
0x3a, 0x12, 0x76, 0xf7, 0x90, 0x00, 0x60, 0xe0, 0x30, 0xe0, 0x11, 0x54,
0xfe, 0xf0, 0x90, 0x00, 0x67, 0xe0, 0x04, 0xf0, 0x70, 0x06, 0x90, 0x00,
0x66, 0xe0, 0x04, 0xf0, 0x90, 0x00, 0x66, 0xe0, 0xb4, 0xff, 0x0c, 0xa3,
0xe0, 0xb4, 0xff, 0x07, 0xe4, 0xfd, 0x7f, 0x16, 0x12, 0x34, 0x1e, 0xe4,
0xf5, 0x10, 0xf5, 0x11, 0x90, 0x04, 0x83, 0xe0, 0xa3, 0xf0, 0x7f, 0x1e,
0x12, 0x78, 0xb8, 0x8e, 0x0e, 0x8f, 0x0f, 0xe5, 0x0e, 0x13, 0x13, 0x13,
0x54, 0x1f, 0x90, 0x04, 0x83, 0xf0, 0xef, 0x54, 0x10, 0x70, 0x11, 0xe5,
0x0f, 0x78, 0x05, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x54, 0x3f,
0xff, 0x12, 0x0a, 0x4b, 0x90, 0x04, 0x11, 0xe0, 0x60, 0x2f, 0x64, 0x01,
0x70, 0x03, 0x02, 0x0a, 0x4a, 0x90, 0x04, 0x11, 0xe0, 0xb4, 0x02, 0x03,
0x02, 0x3c, 0xe9, 0x90, 0x04, 0x11, 0xe0, 0xb4, 0x03, 0x03, 0x02, 0x37,
0xc5, 0x90, 0x04, 0x11, 0xe0, 0xb4, 0x04, 0x03, 0x02, 0x11, 0xde, 0x90,
0x04, 0x11, 0xe0, 0xb4, 0x05, 0x03, 0x02, 0x52, 0xa7, 0xe4, 0x90, 0x04,
0x48, 0xf0, 0x90, 0x04, 0x00, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x20,
0xe0, 0x5f, 0x90, 0x04, 0x00, 0xe0, 0xc3, 0x13, 0x30, 0xe0, 0x56, 0x90,
0x04, 0x83, 0xe0, 0xd3, 0x94, 0x03, 0x40, 0x4d, 0x90, 0x04, 0x89, 0xe0,
0x60, 0x47, 0x7f, 0x1a, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0x70, 0x3d,
0x12, 0x67, 0x47, 0xa8, 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xc3, 0x74, 0xff,
0x9f, 0xf5, 0x0d, 0x74, 0xff, 0x9a, 0xf5, 0x0c, 0x74, 0xff, 0x99, 0xf5,
0x0b, 0x74, 0xff, 0x98, 0xf5, 0x0a, 0x7f, 0x60, 0x7e, 0xea, 0x7d, 0xff,
0x7c, 0xff, 0xab, 0x0d, 0xaa, 0x0c, 0xa9, 0x0b, 0xf8, 0xc3, 0x12, 0x26,
0x2a, 0x40, 0x0a, 0x7d, 0x02, 0x7f, 0x1e, 0x12, 0x34, 0x1e, 0x02, 0x04,
0xd9, 0x90, 0x04, 0x84, 0xe0, 0x70, 0x0d, 0x90, 0x04, 0x83, 0xe0, 0x60,
0x07, 0x7d, 0x02, 0x7f, 0x03, 0x12, 0x34, 0x1e, 0x90, 0x04, 0x83, 0xe0,
0x14, 0x70, 0x03, 0x02, 0x03, 0x50, 0x04, 0x60, 0x03, 0x02, 0x04, 0x20,
0x90, 0x04, 0x84, 0xe0, 0x60, 0x07, 0x7d, 0x02, 0x7f, 0x01, 0x12, 0x34,
0x1e, 0x7f, 0x89, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x07, 0xc3, 0x13, 0xff,
0x14, 0x60, 0x1c, 0x04, 0x60, 0x03, 0x02, 0x02, 0xa8, 0x90, 0x04, 0x3f,
0xe0, 0x60, 0x03, 0x12, 0x76, 0x0d, 0x75, 0xa5, 0x10, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0xef, 0x75, 0x9a, 0x10, 0x22, 0x7d, 0x18, 0x7f, 0xd1, 0x12,
0x78, 0xdf, 0xef, 0x13, 0x13, 0x54, 0x3f, 0x70, 0x1d, 0x75, 0xa4, 0x04,
0x75, 0xa6, 0x03, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x18,
0x7f, 0x0d, 0x7e, 0x00, 0x7d, 0x00, 0x7c, 0x00, 0x12, 0x70, 0x0d, 0x02,
0x77, 0xf7, 0x7d, 0x18, 0x7f, 0xd1, 0x12, 0x78, 0xdf, 0xef, 0x13, 0x13,
0x54, 0x3f, 0x64, 0x01, 0x70, 0x18, 0x12, 0x78, 0xd7, 0xef, 0x70, 0x03,
0x02, 0x0a, 0x4a, 0x75, 0xa4, 0x50, 0x75, 0xa6, 0x03, 0x75, 0xa7, 0xff,
0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x18, 0x7f, 0x86, 0x12, 0x78, 0xeb, 0xef,
0x54, 0x01, 0xf5, 0x09, 0x60, 0x1a, 0x12, 0x78, 0xf6, 0x90, 0x04, 0x3c,
0xe0, 0x30, 0xe0, 0x01, 0x22, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x86, 0x12, 0x76, 0x36, 0x75, 0xa4, 0x02, 0x75,
0xa6, 0xfd, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x85, 0x12, 0x76, 0x0d, 0x90,
0x04, 0x01, 0xe0, 0x30, 0xe0, 0x03, 0x12, 0x48, 0x81, 0x7f, 0x8b, 0x12,
0x78, 0xeb, 0xef, 0x54, 0x0f, 0x75, 0x0e, 0x00, 0xf5, 0x0f, 0x7d, 0x96,
0xe4, 0xff, 0x12, 0x78, 0xdf, 0xef, 0x54, 0x03, 0xc3, 0x13, 0x75, 0xf0,
0x10, 0xa4, 0xae, 0xf0, 0x42, 0x0f, 0xee, 0x42, 0x0e, 0xaf, 0x0f, 0x7d,
0x02, 0x12, 0x40, 0x1f, 0x90, 0x04, 0x00, 0x12, 0x40, 0x1b, 0x12, 0x40,
0x17, 0x7d, 0x02, 0x7f, 0x02, 0x12, 0x34, 0x1e, 0x12, 0x21, 0xbf, 0x90,
0x04, 0x00, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x20, 0xe0, 0x23, 0x90,
0x04, 0x89, 0xe0, 0x60, 0x1d, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x63, 0x75, 0xa4, 0xd0, 0x75, 0xa6, 0x03, 0x75,
0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x18, 0x80, 0x1b, 0x75, 0xa4,
0x50, 0x75, 0xa6, 0x03, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c,
0x18, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x63, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x85, 0x75, 0xa5, 0x10, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xef, 0x75, 0x9a,
0x10, 0x90, 0x04, 0x0b, 0xe0, 0x04, 0xf0, 0x22, 0x90, 0x04, 0x3f, 0xe0,
0x60, 0x03, 0x12, 0x76, 0x0d, 0x90, 0x04, 0x48, 0x74, 0x01, 0xf0, 0x7f,
0xf6, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0xf5, 0x09, 0x60, 0x12, 0x90,
0x00, 0x6c, 0x74, 0xff, 0xf0, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0xf6, 0x7f, 0xf8, 0x12, 0x78, 0xeb, 0xef, 0x54,
0x07, 0xc3, 0x13, 0x64, 0x01, 0x70, 0x5b, 0x75, 0xa4, 0x02, 0x75, 0xa6,
0xfd, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0xf5, 0xe4, 0x90, 0x00, 0x64, 0xf0,
0x90, 0x00, 0x50, 0xe0, 0xff, 0x7d, 0x01, 0x12, 0x40, 0x1f, 0x90, 0x00,
0x50, 0xa3, 0xe0, 0xff, 0x7d, 0x01, 0x12, 0x40, 0x1f, 0xe4, 0xfd, 0x7f,
0x05, 0x12, 0x34, 0x1e, 0x90, 0x00, 0x6c, 0xe0, 0x30, 0xe0, 0x03, 0x12,
0x78, 0xf9, 0x90, 0x00, 0x6c, 0xe0, 0x54, 0xfe, 0xf0, 0x12, 0x77, 0x1b,
0x90, 0x00, 0x51, 0xe0, 0x30, 0xe0, 0x03, 0x12, 0x78, 0x94, 0x12, 0x68,
0xa6, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0xf5, 0x22, 0x90, 0x00, 0x64, 0xe0, 0x60, 0x03, 0x02, 0x0a, 0x4a, 0x04,
0xf0, 0xe4, 0xfd, 0x7f, 0x04, 0x02, 0x34, 0x1e, 0x90, 0x04, 0x3f, 0xe0,
0x60, 0x5f, 0x90, 0x04, 0x02, 0xe0, 0x70, 0x06, 0x90, 0x04, 0x3e, 0xe0,
0x70, 0x53, 0x12, 0x76, 0x0d, 0x90, 0x04, 0x00, 0xe0, 0xc3, 0x13, 0xa3,
0xe0, 0x13, 0x20, 0xe0, 0x3b, 0x7d, 0x96, 0xe4, 0xff, 0x12, 0x78, 0xdf,
0xef, 0x54, 0x03, 0xc3, 0x13, 0x60, 0x2d, 0x75, 0xa4, 0x01, 0x75, 0xa6,
0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x17, 0x75, 0xa4,
0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0xe4, 0xf5, 0x9e, 0x75, 0x9c,
0x96, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9e,
0xd1, 0x75, 0x9c, 0x17, 0x90, 0x04, 0x3d, 0xe0, 0x44, 0x01, 0xf0, 0x80,
0x05, 0xe4, 0x90, 0x04, 0x40, 0xf0, 0x75, 0xa5, 0x20, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0xdf, 0x75, 0x9a, 0x10, 0x7f, 0x1e, 0x12, 0x78, 0xe6, 0xef,
0x13, 0x13, 0x13, 0x54, 0x1f, 0x90, 0x04, 0x83, 0xf0, 0x64, 0x01, 0x60,
0x1f, 0x90, 0x04, 0x0a, 0xe0, 0x04, 0xf0, 0x7f, 0x1d, 0x12, 0x78, 0xeb,
0xef, 0x54, 0x07, 0x75, 0x0e, 0x00, 0xf5, 0x0f, 0xff, 0x7d, 0x02, 0x12,
0x40, 0x1f, 0x7d, 0x02, 0x7f, 0x07, 0x80, 0x1f, 0x90, 0x04, 0x84, 0xe0,
0x64, 0x01, 0x60, 0x1a, 0x7f, 0x1d, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x07,
0x75, 0x0e, 0x00, 0xf5, 0x0f, 0xff, 0x7d, 0x02, 0x12, 0x40, 0x1f, 0x7d,
0x02, 0x7f, 0x06, 0x12, 0x34, 0x1e, 0x90, 0x04, 0x48, 0x02, 0x05, 0x9b,
0x90, 0x04, 0x83, 0xe0, 0x64, 0x02, 0x70, 0x1f, 0x90, 0x04, 0x40, 0xe0,
0x60, 0x19, 0x90, 0x04, 0x3f, 0x74, 0x01, 0xf0, 0x7d, 0x02, 0x7f, 0x02,
0x12, 0x40, 0x1f, 0x7d, 0x02, 0x7f, 0x15, 0x12, 0x34, 0x1e, 0x80, 0x00,
0x02, 0x04, 0xd9, 0x90, 0x04, 0x40, 0xe0, 0xb4, 0x25, 0x00, 0x50, 0x76,
0x90, 0x04, 0x57, 0xf8, 0x28, 0x28, 0x73, 0x02, 0x04, 0xe6, 0x02, 0x05,
0x90, 0x02, 0x09, 0xe1, 0x02, 0x05, 0xb4, 0x02, 0x05, 0xb4, 0x02, 0x05,
0xb4, 0x02, 0x05, 0xde, 0x02, 0x05, 0xde, 0x02, 0x05, 0xde, 0x02, 0x07,
0x24, 0x02, 0x05, 0xf4, 0x02, 0x06, 0x7f, 0x02, 0x09, 0xf3, 0x02, 0x07,
0x41, 0x02, 0x07, 0x5c, 0x02, 0x07, 0x70, 0x02, 0x07, 0xc3, 0x02, 0x08,
0xf1, 0x02, 0x09, 0x42, 0x02, 0x09, 0x52, 0x02, 0x06, 0x91, 0x02, 0x0a,
0x1f, 0x02, 0x08, 0xc3, 0x02, 0x07, 0x7b, 0x02, 0x07, 0x7b, 0x02, 0x04,
0xc6, 0x02, 0x07, 0x7b, 0x02, 0x07, 0x7b, 0x02, 0x07, 0x7b, 0x02, 0x07,
0x7b, 0x02, 0x07, 0x7b, 0x02, 0x07, 0x7b, 0x02, 0x07, 0x7b, 0x02, 0x07,
0x7b, 0x02, 0x09, 0x37, 0x02, 0x08, 0x9b, 0x02, 0x08, 0x9b, 0x90, 0x04,
0x3f, 0x74, 0x01, 0xf0, 0x7d, 0x02, 0xff, 0x12, 0x40, 0x1f, 0x7d, 0x02,
0x7f, 0x15, 0x12, 0x34, 0x1e, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x19, 0x22, 0x90, 0x04, 0x3f, 0x74, 0x01, 0xf0,
0x90, 0x04, 0x3d, 0xe0, 0x54, 0xfe, 0xf0, 0x7f, 0xff, 0x7e, 0xff, 0x7d,
0xff, 0x7c, 0xff, 0x12, 0x70, 0x0d, 0x12, 0x77, 0xf7, 0x90, 0x04, 0x3f,
0xe0, 0x60, 0x11, 0x90, 0x04, 0x02, 0xe0, 0x70, 0x06, 0x90, 0x04, 0x3e,
0xe0, 0x70, 0x05, 0x12, 0x45, 0xeb, 0x80, 0x0f, 0xe4, 0xf5, 0xa4, 0x75,
0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10, 0x12, 0x72, 0xe1, 0x7f,
0x8b, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x0f, 0x75, 0x0e, 0x00, 0xf5, 0x0f,
0x7d, 0x96, 0xe4, 0xff, 0x12, 0x78, 0xdf, 0xef, 0x54, 0x03, 0xc3, 0x13,
0x75, 0xf0, 0x10, 0xa4, 0xae, 0xf0, 0x42, 0x0f, 0xee, 0x42, 0x0e, 0xaf,
0x0f, 0x7d, 0x02, 0x12, 0x40, 0x1f, 0x90, 0x04, 0x00, 0x12, 0x40, 0x1b,
0x12, 0x40, 0x17, 0x7d, 0x02, 0x7f, 0x1a, 0x12, 0x34, 0x1e, 0x90, 0x00,
0x50, 0x12, 0x40, 0x1b, 0x90, 0x00, 0x50, 0x12, 0x40, 0x1a, 0x7d, 0x02,
0x7f, 0x19, 0x12, 0x34, 0x1e, 0x75, 0xa5, 0x40, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xbf, 0x75, 0x9a, 0x10, 0x7f, 0x1e, 0x12, 0x78, 0xe6, 0xef, 0x13,
0x13, 0x13, 0x54, 0x1f, 0x90, 0x04, 0x83, 0xf0, 0x90, 0x04, 0x83, 0xe0,
0x64, 0x07, 0x60, 0x07, 0x90, 0x04, 0x40, 0x74, 0x01, 0xf0, 0x22, 0x90,
0x04, 0x02, 0xe0, 0x70, 0x0f, 0x90, 0x04, 0x3e, 0xe0, 0x60, 0x09, 0x90,
0x04, 0x40, 0x74, 0x13, 0xf0, 0x02, 0x09, 0x52, 0x12, 0x5e, 0x92, 0xef,
0x64, 0x02, 0x70, 0x03, 0x02, 0x0a, 0x4a, 0x75, 0xa4, 0x80, 0x75, 0xa6,
0x7f, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x01, 0xe4, 0xf5, 0xa4, 0x75, 0xa6,
0x7f, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x01, 0x90, 0x04, 0x40, 0x74, 0x06,
0xf0, 0x22, 0x12, 0x5b, 0xcb, 0xef, 0x64, 0x02, 0x70, 0x03, 0x02, 0x0a,
0x4a, 0x12, 0x5b, 0xcb, 0xef, 0x64, 0x01, 0x70, 0x03, 0x02, 0x0a, 0x4a,
0x12, 0x6f, 0x71, 0xef, 0x64, 0x02, 0x70, 0x03, 0x02, 0x0a, 0x4a, 0x90,
0x04, 0x49, 0xe0, 0x60, 0x1a, 0x64, 0x01, 0x60, 0x03, 0x02, 0x06, 0x91,
0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13,
0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x72, 0x90, 0x04, 0x00, 0xe0, 0xfe,
0xa3, 0xe0, 0x78, 0x07, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20,
0xe0, 0x5f, 0x7f, 0x1e, 0x12, 0x73, 0x80, 0x12, 0x71, 0x32, 0x90, 0x00,
0x5f, 0xe0, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce,
0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x90, 0x04, 0x20, 0x30, 0xe0, 0x08,
0xe4, 0xf0, 0xa3, 0x74, 0x05, 0xf0, 0x80, 0x06, 0xe4, 0xf0, 0xa3, 0x74,
0x14, 0xf0, 0x7f, 0x09, 0x12, 0x73, 0xe6, 0x7d, 0x04, 0x7f, 0x26, 0x12,
0x34, 0x1e, 0x12, 0x78, 0xc3, 0x90, 0x04, 0x56, 0xef, 0xf0, 0x12, 0x75,
0x3a, 0x90, 0x04, 0x40, 0x74, 0x0b, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70,
0x03, 0x02, 0x0a, 0x4a, 0x12, 0x67, 0xbd, 0x90, 0x04, 0x4d, 0xe0, 0x60,
0xe5, 0xe4, 0x90, 0x04, 0x48, 0xf0, 0x90, 0x04, 0x4a, 0xf0, 0x90, 0x04,
0x4a, 0xe0, 0xc3, 0x94, 0x04, 0x40, 0x03, 0x02, 0x08, 0x04, 0x90, 0x04,
0x41, 0xe0, 0x64, 0x28, 0x60, 0x04, 0xe0, 0xb4, 0x29, 0x0b, 0x90, 0x04,
0x4a, 0xe0, 0x64, 0x01, 0x70, 0x03, 0x02, 0x08, 0x04, 0x90, 0x04, 0x49,
0xe0, 0x60, 0x16, 0xb4, 0x01, 0x2c, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3,
0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0,
0x19, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x07, 0xce, 0xc3,
0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x06, 0xe4, 0x90, 0x04, 0x5c,
0x80, 0x05, 0x90, 0x04, 0x5c, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x5e, 0xf0,
0x90, 0x04, 0x49, 0xe0, 0xc3, 0x94, 0x02, 0x40, 0x3c, 0x75, 0xa4, 0x02,
0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x18, 0x75, 0xa5, 0x03,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfc, 0x75, 0x9a, 0x18, 0x90, 0x04, 0x40,
0x74, 0x09, 0xf0, 0x22, 0xe4, 0x90, 0x04, 0x40, 0xf0, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x18, 0xe4, 0xf5, 0xa5,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfc, 0x75, 0x9a, 0x18, 0x12, 0x70, 0xe7,
0xef, 0x60, 0x03, 0x02, 0x0a, 0x4a, 0x90, 0x04, 0x5c, 0xe0, 0xb4, 0x01,
0x0b, 0x90, 0x04, 0x5e, 0xe0, 0x64, 0x01, 0x70, 0x03, 0x02, 0x07, 0xf3,
0x12, 0x70, 0x56, 0xef, 0x64, 0x02, 0x70, 0x03, 0x02, 0x0a, 0x4a, 0x90,
0x04, 0x8a, 0xe0, 0x60, 0x03, 0x02, 0x09, 0x0b, 0x12, 0x65, 0x5d, 0xef,
0x64, 0x02, 0x70, 0x03, 0x02, 0x0a, 0x4a, 0x7d, 0x04, 0x7f, 0x27, 0x12,
0x34, 0x1e, 0x90, 0x04, 0x3c, 0xe0, 0xff, 0x13, 0x13, 0x54, 0x3f, 0x30,
0xe0, 0x0f, 0x90, 0x04, 0x4c, 0xe0, 0x64, 0x01, 0x60, 0x07, 0x12, 0x6a,
0x00, 0xbf, 0x02, 0x0c, 0x22, 0x12, 0x47, 0x37, 0xef, 0x64, 0x02, 0x70,
0x03, 0x02, 0x0a, 0x4a, 0x90, 0x04, 0x7b, 0xe0, 0x60, 0x03, 0x02, 0x08,
0x9b, 0x90, 0x04, 0x5c, 0xe0, 0xb4, 0x02, 0x05, 0x74, 0x01, 0xf0, 0x80,
0x18, 0x90, 0x04, 0x5c, 0xe0, 0x70, 0x12, 0x7d, 0x04, 0x7f, 0x28, 0x12,
0x34, 0x1e, 0x12, 0x39, 0x89, 0xef, 0x64, 0x02, 0x70, 0x03, 0x02, 0x0a,
0x4a, 0x90, 0x04, 0x5c, 0xe0, 0x64, 0x01, 0x60, 0x03, 0x02, 0x07, 0x4a,
0x90, 0x04, 0x5e, 0xe0, 0xb4, 0x02, 0x06, 0x74, 0x01, 0xf0, 0x02, 0x07,
0x4a, 0x12, 0x3b, 0x4b, 0x02, 0x07, 0x4a, 0x90, 0x04, 0x4c, 0xe0, 0x64,
0x01, 0x60, 0x09, 0x90, 0x04, 0x4a, 0xe0, 0x04, 0xf0, 0x02, 0x06, 0x9a,
0x90, 0x04, 0x49, 0xe0, 0x60, 0x03, 0x02, 0x08, 0xaf, 0x90, 0x04, 0x00,
0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8,
0xf9, 0x20, 0xe0, 0x03, 0x02, 0x08, 0xaf, 0x90, 0x04, 0x04, 0xe0, 0x30,
0xe7, 0x0c, 0x54, 0x7f, 0xff, 0x90, 0x04, 0x45, 0xf0, 0x12, 0x63, 0x09,
0x80, 0x79, 0x90, 0x04, 0x00, 0xe0, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0xa3,
0xe0, 0xc4, 0x54, 0x0f, 0x48, 0x54, 0x03, 0x64, 0x02, 0x60, 0x64, 0x90,
0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x07, 0xce, 0xc3, 0x13, 0xce,
0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x51, 0x90, 0x04, 0x87, 0xe0, 0xff, 0xc4,
0x54, 0x0f, 0x20, 0xe0, 0x46, 0x90, 0x04, 0x7f, 0xe0, 0xff, 0xc4, 0x13,
0x54, 0x07, 0x30, 0xe0, 0x13, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3,
0xe0, 0x13, 0x54, 0x1f, 0xd3, 0x94, 0x10, 0xe4, 0x94, 0x00, 0x50, 0x13,
0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x54, 0x1f, 0xd3,
0x94, 0x16, 0xe4, 0x94, 0x00, 0x40, 0x14, 0x12, 0x29, 0x9c, 0xef, 0x64,
0x02, 0x70, 0x03, 0x02, 0x0a, 0x4a, 0x90, 0x04, 0x7b, 0xe0, 0x60, 0x03,
0x02, 0x07, 0x70, 0x90, 0x04, 0x89, 0xe0, 0x60, 0x1c, 0x90, 0x04, 0x41,
0xe0, 0x64, 0x2c, 0x60, 0x14, 0x90, 0x04, 0x40, 0x74, 0x16, 0xf0, 0x12,
0x30, 0x28, 0x90, 0x04, 0x41, 0xe0, 0x64, 0x2c, 0x60, 0x03, 0x02, 0x0a,
0x4a, 0x90, 0x04, 0x4c, 0xe0, 0x64, 0x01, 0x60, 0x37, 0x90, 0x04, 0x00,
0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x07, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8,
0xf9, 0x20, 0xe0, 0x24, 0xe4, 0x90, 0x04, 0x5d, 0xf0, 0x12, 0x5f, 0xe3,
0xef, 0x64, 0x02, 0x70, 0x03, 0x02, 0x0a, 0x4a, 0x90, 0x04, 0x5d, 0xe0,
0x60, 0xef, 0x90, 0x04, 0x8a, 0x74, 0x01, 0xf0, 0x02, 0x07, 0x5c, 0xe4,
0x90, 0x04, 0x8a, 0xf0, 0x12, 0x78, 0xf0, 0xef, 0x60, 0x2c, 0x90, 0x04,
0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x07, 0xce, 0xc3, 0x13, 0xce, 0x13,
0xd8, 0xf9, 0x20, 0xe0, 0x19, 0x90, 0x04, 0x4c, 0xe0, 0x64, 0x01, 0x60,
0x11, 0x90, 0x04, 0x40, 0x74, 0x22, 0xf0, 0x12, 0x62, 0x6d, 0xef, 0x64,
0x02, 0x70, 0x03, 0x02, 0x0a, 0x4a, 0x7d, 0x04, 0x7f, 0x29, 0x12, 0x34,
0x1e, 0x12, 0x4d, 0x53, 0xef, 0x60, 0x03, 0x02, 0x0a, 0x4a, 0x7f, 0x1a,
0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0x60, 0x03, 0x02, 0x09, 0xe1, 0xe4,
0xf5, 0xa4, 0x75, 0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10, 0x75,
0xa4, 0x20, 0x75, 0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10, 0x12,
0x67, 0x47, 0xc3, 0x74, 0xff, 0x9f, 0xff, 0x74, 0xff, 0x9e, 0xfe, 0x74,
0xff, 0x9d, 0xfd, 0x74, 0xff, 0x9c, 0xfc, 0x78, 0x03, 0x12, 0x26, 0x3b,
0x8f, 0x0d, 0x8e, 0x0c, 0x8d, 0x0b, 0x8c, 0x0a, 0xe4, 0xff, 0xfe, 0x7d,
0x01, 0xfc, 0xab, 0x0d, 0xaa, 0x0c, 0xa9, 0x0b, 0xa8, 0x0a, 0xc3, 0x12,
0x26, 0x2a, 0x40, 0x06, 0x7e, 0xff, 0x7f, 0xff, 0x80, 0x04, 0xae, 0x0c,
0xaf, 0x0d, 0x90, 0x04, 0x12, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x04,
0x0c, 0xe0, 0x04, 0xf0, 0x90, 0x04, 0x3e, 0x74, 0x01, 0xf0, 0x7d, 0x02,
0x7f, 0x0e, 0x12, 0x34, 0x1e, 0xe4, 0x90, 0x04, 0x85, 0xf0, 0x90, 0x04,
0x48, 0x04, 0xf0, 0x90, 0x04, 0x40, 0x04, 0xf0, 0x22, 0x90, 0x04, 0x7f,
0xe0, 0xff, 0x13, 0x13, 0x54, 0x3f, 0x30, 0xe0, 0x15, 0x90, 0x04, 0x49,
0xe0, 0x70, 0x08, 0x12, 0x65, 0xda, 0xef, 0x64, 0x02, 0x60, 0x4f, 0x90,
0x04, 0x7f, 0xe0, 0x54, 0xfb, 0xf0, 0x7f, 0x1f, 0x12, 0x75, 0xe3, 0x90,
0x04, 0x40, 0x74, 0x15, 0xf0, 0x75, 0xa4, 0x80, 0x75, 0xa6, 0x7f, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x10, 0x90, 0x04, 0x83, 0x74, 0xff, 0xf0, 0x90,
0x04, 0x48, 0x74, 0x01, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x60, 0x1f, 0x90,
0x04, 0x08, 0xe0, 0xff, 0xc4, 0x13, 0x13, 0x13, 0x54, 0x01, 0x20, 0xe0,
0xd4, 0x90, 0x04, 0x8b, 0xe0, 0x70, 0xce, 0x90, 0x04, 0x4c, 0x04, 0xf0,
0x12, 0x76, 0xd2, 0x02, 0x06, 0x91, 0x22, 0xef, 0xb4, 0x15, 0x00, 0x40,
0x03, 0x02, 0x11, 0xdd, 0x90, 0x0a, 0x5b, 0xf8, 0x28, 0x28, 0x73, 0x02,
0x0a, 0x9a, 0x02, 0x0a, 0xa7, 0x02, 0x11, 0xdd, 0x02, 0x11, 0xdd, 0x02,
0x0a, 0xfe, 0x02, 0x0b, 0x6a, 0x02, 0x0d, 0x3c, 0x02, 0x0d, 0x74, 0x02,
0x0d, 0xac, 0x02, 0x0d, 0xd0, 0x02, 0x0d, 0xef, 0x02, 0x0e, 0x4c, 0x02,
0x0e, 0x9b, 0x02, 0x0e, 0xd3, 0x02, 0x11, 0xdd, 0x02, 0x0f, 0x14, 0x02,
0x0f, 0xfd, 0x02, 0x10, 0xd5, 0x02, 0x11, 0x2d, 0x02, 0x10, 0x98, 0x02,
0x11, 0xcb, 0x75, 0xa4, 0x80, 0x75, 0xa6, 0x3f, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0x0d, 0x22, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0x7e, 0x00, 0xe4, 0x70,
0x48, 0xef, 0x14, 0x60, 0x12, 0x14, 0x60, 0x17, 0x24, 0x02, 0x70, 0x3d,
0x90, 0x04, 0x48, 0xe0, 0x70, 0x03, 0x02, 0x11, 0xdd, 0x80, 0x00, 0x90,
0x04, 0x11, 0x74, 0x01, 0x02, 0x0c, 0x7e, 0x90, 0x04, 0x3f, 0x74, 0x01,
0xf0, 0xe4, 0x90, 0x04, 0x11, 0xf0, 0x12, 0x76, 0xd2, 0x7f, 0x1a, 0x12,
0x78, 0xeb, 0xef, 0x54, 0x01, 0x70, 0x03, 0x02, 0x0d, 0x71, 0x75, 0xa4,
0x20, 0x75, 0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10, 0x02, 0x0d,
0x71, 0x7f, 0x01, 0x02, 0x10, 0x46, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0x7e,
0x00, 0xe4, 0x70, 0x5f, 0xef, 0x14, 0x60, 0x32, 0x14, 0x60, 0x3d, 0x14,
0x60, 0x46, 0x24, 0x03, 0x70, 0x51, 0xd3, 0x90, 0x00, 0x53, 0xe0, 0x94,
0x00, 0x90, 0x00, 0x52, 0xe0, 0x94, 0x00, 0x40, 0x0b, 0xe0, 0xfe, 0xa3,
0xe0, 0xf5, 0xa4, 0xee, 0xf5, 0xa5, 0x80, 0x34, 0x12, 0x78, 0x6b, 0xef,
0xf5, 0xa4, 0x12, 0x78, 0x6b, 0xee, 0xf5, 0xa5, 0x80, 0x26, 0x12, 0x76,
0xf7, 0xef, 0xf5, 0xa4, 0x12, 0x76, 0xf7, 0xee, 0xf5, 0xa5, 0x80, 0x18,
0xaf, 0x38, 0xad, 0x07, 0xed, 0xf5, 0xa4, 0xe4, 0xf5, 0xa5, 0x80, 0x0c,
0x12, 0x67, 0x47, 0xef, 0xf5, 0xa4, 0x12, 0x67, 0x47, 0xee, 0xf5, 0xa5,
0x75, 0x9a, 0x0e, 0x02, 0x0d, 0x71, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0x7e,
0x00, 0xe4, 0x60, 0x03, 0x02, 0x11, 0xdd, 0xef, 0x24, 0xfe, 0x70, 0x03,
0x02, 0x0c, 0x13, 0x14, 0x70, 0x03, 0x02, 0x0c, 0x39, 0x14, 0x70, 0x03,
0x02, 0x0c, 0x82, 0x14, 0x70, 0x03, 0x02, 0x0c, 0xdb, 0x14, 0x60, 0x03,
0x02, 0x11, 0xdd, 0x90, 0x04, 0x11, 0xe0, 0xff, 0xd3, 0x94, 0x01, 0x40,
0x07, 0xef, 0x44, 0xc0, 0xff, 0x02, 0x10, 0x46, 0x90, 0x04, 0x49, 0xe0,
0xd3, 0x94, 0x01, 0x40, 0x05, 0x7f, 0xd2, 0x02, 0x10, 0x46, 0x90, 0x04,
0x48, 0xe0, 0x70, 0x0c, 0x90, 0x04, 0x11, 0xe0, 0xd3, 0x94, 0x00, 0x50,
0x03, 0x02, 0x11, 0xdd, 0x90, 0x04, 0x11, 0xe0, 0xd3, 0x94, 0x00, 0x7f,
0x00, 0x40, 0x02, 0x7f, 0x01, 0x90, 0x04, 0x4e, 0xef, 0xf0, 0x7f, 0x0e,
0x12, 0x78, 0xb8, 0x90, 0x04, 0x24, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x12,
0x4f, 0x9b, 0x8f, 0x15, 0xe5, 0x15, 0xd3, 0x94, 0x00, 0x40, 0x08, 0xe5,
0x15, 0x44, 0x60, 0xff, 0x02, 0x10, 0x46, 0x90, 0x04, 0x11, 0x74, 0x05,
0xf0, 0x90, 0x04, 0x24, 0xe0, 0xfe, 0xa3, 0xe0, 0xf5, 0xa4, 0xee, 0xf5,
0xa5, 0x75, 0x9a, 0x0e, 0x02, 0x0d, 0x71, 0x90, 0x04, 0x48, 0xe0, 0x70,
0x0c, 0x90, 0x04, 0x11, 0xe0, 0xd3, 0x94, 0x00, 0x50, 0x03, 0x02, 0x11,
0xdd, 0x90, 0x04, 0x11, 0xe0, 0x90, 0x04, 0x4e, 0xf0, 0x90, 0x04, 0x11,
0x74, 0x01, 0xf0, 0x12, 0x78, 0x0d, 0x02, 0x0d, 0x71, 0x90, 0x04, 0x3f,
0x74, 0x01, 0xf0, 0x90, 0x04, 0x11, 0xe0, 0xd3, 0x94, 0x01, 0x40, 0x20,
0xe4, 0x90, 0x00, 0x5a, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0x58, 0xf0, 0xa3,
0xf0, 0x7e, 0x02, 0x7f, 0xf8, 0xfd, 0x7b, 0x01, 0x7a, 0x01, 0x79, 0x00,
0x12, 0x26, 0xc1, 0xe4, 0x90, 0x00, 0x65, 0xf0, 0x12, 0x74, 0xb2, 0x90,
0x04, 0x4e, 0xe0, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x7f, 0x00, 0x40, 0x02,
0x7f, 0x01, 0x90, 0x04, 0x11, 0xef, 0xf0, 0x02, 0x0d, 0x71, 0x90, 0x04,
0x11, 0xe0, 0xff, 0xd3, 0x94, 0x01, 0x40, 0x10, 0x90, 0x00, 0x65, 0xe0,
0xc4, 0x54, 0xf0, 0x44, 0xc0, 0xfe, 0xef, 0x4e, 0xff, 0x02, 0x10, 0x46,
0x90, 0x04, 0x49, 0xe0, 0xd3, 0x94, 0x01, 0x40, 0x05, 0x7f, 0xd2, 0x02,
0x10, 0x46, 0x90, 0x04, 0x48, 0xe0, 0x70, 0x0c, 0x90, 0x04, 0x11, 0xe0,
0xd3, 0x94, 0x00, 0x50, 0x03, 0x02, 0x11, 0xdd, 0x90, 0x00, 0x65, 0x74,
0x01, 0xf0, 0x90, 0x04, 0x11, 0xe0, 0xd3, 0x94, 0x00, 0x7f, 0x00, 0x40,
0x02, 0x7f, 0x01, 0x90, 0x04, 0x4e, 0xef, 0xf0, 0x90, 0x04, 0x11, 0x74,
0x02, 0x80, 0x57, 0x90, 0x04, 0x11, 0xe0, 0xff, 0xd3, 0x94, 0x01, 0x40,
0x10, 0x90, 0x00, 0x65, 0xe0, 0xc4, 0x54, 0xf0, 0x44, 0xc0, 0xfe, 0xef,
0x4e, 0xff, 0x02, 0x10, 0x46, 0x90, 0x04, 0x49, 0xe0, 0xd3, 0x94, 0x01,
0x40, 0x05, 0x7f, 0xd2, 0x02, 0x10, 0x46, 0x90, 0x04, 0x48, 0xe0, 0x70,
0x0c, 0x90, 0x04, 0x11, 0xe0, 0xd3, 0x94, 0x00, 0x50, 0x03, 0x02, 0x11,
0xdd, 0x90, 0x00, 0x65, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x11, 0xe0, 0xd3,
0x94, 0x00, 0x7f, 0x00, 0x40, 0x02, 0x7f, 0x01, 0x90, 0x04, 0x4e, 0xef,
0xf0, 0x90, 0x04, 0x11, 0x74, 0x03, 0xf0, 0x12, 0x6e, 0x1a, 0x12, 0x75,
0x3a, 0x02, 0x10, 0x95, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0xef, 0xf5, 0x14,
0xc3, 0x94, 0x80, 0x7e, 0x00, 0x7b, 0x01, 0x50, 0x09, 0x74, 0x00, 0x2f,
0xf9, 0xee, 0x34, 0x04, 0x80, 0x08, 0x74, 0x80, 0x25, 0x14, 0xf9, 0xee,
0x34, 0x04, 0xfa, 0x12, 0x25, 0xb5, 0x8e, 0x12, 0xf5, 0x13, 0xe5, 0x13,
0xf5, 0xa4, 0xe5, 0x12, 0xf5, 0xa5, 0x75, 0x9a, 0x0e, 0x02, 0x10, 0x95,
0x7f, 0x0d, 0x12, 0x78, 0xe6, 0xef, 0xf5, 0x14, 0x7f, 0x0e, 0x12, 0x78,
0xb8, 0x75, 0x12, 0x00, 0x8f, 0x13, 0xe5, 0x14, 0xc3, 0x94, 0x80, 0xe5,
0x14, 0x7c, 0x00, 0x7b, 0x01, 0x50, 0x0a, 0x24, 0x00, 0xf9, 0xec, 0x34,
0x04, 0xfa, 0xef, 0x80, 0x09, 0x24, 0x80, 0xf9, 0xec, 0x34, 0x04, 0xfa,
0xe5, 0x13, 0x12, 0x25, 0xf0, 0x02, 0x10, 0x95, 0x7f, 0x0d, 0x12, 0x78,
0xe6, 0xef, 0x7e, 0x00, 0x7b, 0x01, 0x24, 0x50, 0xf9, 0xee, 0x34, 0x00,
0xfa, 0x12, 0x25, 0xb5, 0x8e, 0x12, 0xf5, 0x13, 0xf5, 0xa4, 0xe5, 0x12,
0xf5, 0xa5, 0x75, 0x9a, 0x0e, 0x02, 0x10, 0x95, 0x7f, 0x0e, 0x12, 0x78,
0xb8, 0x75, 0x12, 0x00, 0x8f, 0x13, 0xc0, 0x07, 0x7f, 0x0d, 0x12, 0x78,
0xe6, 0xef, 0x7e, 0x00, 0x7b, 0x01, 0x24, 0x50, 0xf9, 0xee, 0x34, 0x00,
0x02, 0x0f, 0x0b, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0xef, 0xf5, 0x14, 0xc3,
0x94, 0x80, 0x50, 0x1e, 0xef, 0xfd, 0x7c, 0x00, 0x7b, 0x01, 0x24, 0x00,
0xf9, 0xec, 0x34, 0x04, 0xfa, 0x12, 0x25, 0xb5, 0x75, 0x13, 0x00, 0xf5,
0x12, 0x74, 0x01, 0x2d, 0xf9, 0xec, 0x34, 0x04, 0x80, 0x1d, 0xe5, 0x14,
0xfd, 0x7c, 0x00, 0x7b, 0x01, 0x24, 0x80, 0xf9, 0xec, 0x34, 0x04, 0xfa,
0x12, 0x25, 0xb5, 0x75, 0x13, 0x00, 0xf5, 0x12, 0x74, 0x81, 0x2d, 0xf9,
0xec, 0x34, 0x04, 0xfa, 0x12, 0x25, 0xb5, 0x42, 0x13, 0xe4, 0xe5, 0x13,
0xf5, 0xa4, 0xe5, 0x12, 0xf5, 0xa5, 0x75, 0x9a, 0x0e, 0x02, 0x10, 0x95,
0x7f, 0x0e, 0x12, 0x78, 0xb8, 0x8e, 0x12, 0x8f, 0x13, 0x7f, 0x0d, 0x12,
0x78, 0xe6, 0xef, 0xf5, 0x14, 0xc3, 0x94, 0x80, 0xe5, 0x12, 0xff, 0xe5,
0x14, 0xfd, 0x7c, 0x00, 0x7b, 0x01, 0x50, 0x14, 0x24, 0x00, 0xf9, 0xec,
0x34, 0x04, 0xfa, 0xef, 0x12, 0x25, 0xf0, 0x74, 0x01, 0x2d, 0xf9, 0xec,
0x34, 0x04, 0x80, 0x12, 0x24, 0x80, 0xf9, 0xec, 0x34, 0x04, 0xfa, 0xef,
0x12, 0x25, 0xf0, 0x74, 0x81, 0x2d, 0xf9, 0xec, 0x34, 0x04, 0xfa, 0xe5,
0x13, 0x12, 0x25, 0xf0, 0x02, 0x10, 0x95, 0x7f, 0x0d, 0x12, 0x78, 0xe6,
0xef, 0xf5, 0x14, 0xfd, 0x7c, 0x00, 0x7b, 0x01, 0x24, 0x50, 0xf9, 0xec,
0x34, 0x00, 0xfa, 0x12, 0x25, 0xb5, 0x75, 0x13, 0x00, 0xf5, 0x12, 0x74,
0x51, 0x2d, 0xf9, 0xec, 0x34, 0x00, 0xfa, 0x12, 0x25, 0xb5, 0x42, 0x13,
0xe4, 0xe5, 0x13, 0xf5, 0xa4, 0xe5, 0x12, 0xf5, 0xa5, 0x75, 0x9a, 0x0e,
0x02, 0x10, 0x95, 0x7f, 0x0e, 0x12, 0x78, 0xb8, 0x8e, 0x12, 0x8f, 0x13,
0xe5, 0x12, 0xff, 0xc0, 0x07, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0xef, 0x7e,
0x00, 0x7b, 0x01, 0x24, 0x50, 0xf9, 0xee, 0x34, 0x00, 0xfa, 0xd0, 0xe0,
0x12, 0x25, 0xf0, 0xaf, 0x13, 0xc0, 0x07, 0x7f, 0x0d, 0x12, 0x78, 0xe6,
0xef, 0x7e, 0x00, 0x7b, 0x01, 0x24, 0x51, 0xf9, 0xee, 0x34, 0x00, 0xfa,
0xd0, 0xe0, 0x12, 0x25, 0xf0, 0x02, 0x11, 0xc9, 0x90, 0x04, 0x11, 0xe0,
0xd3, 0x94, 0x01, 0x40, 0x03, 0x02, 0x0f, 0xf9, 0x7f, 0x0d, 0x12, 0x78,
0xe6, 0x7e, 0x00, 0xe4, 0x60, 0x03, 0x02, 0x11, 0xdd, 0xef, 0x14, 0x60,
0x44, 0x14, 0x70, 0x03, 0x02, 0x0f, 0xd5, 0x24, 0x02, 0x60, 0x03, 0x02,
0x11, 0xdd, 0xe4, 0xfd, 0x7f, 0x11, 0x12, 0x34, 0x1e, 0x90, 0x00, 0x65,
0x74, 0x01, 0xf0, 0x90, 0x00, 0x5a, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x4e,
0x70, 0x0a, 0x7c, 0x02, 0x7d, 0xf7, 0x7e, 0x02, 0x7f, 0xf7, 0x80, 0x08,
0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0x90, 0x00, 0x58, 0xee,
0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0xff, 0x02, 0x0f, 0xf6, 0x90, 0x00, 0x58,
0xe0, 0xfe, 0xa3, 0xe0, 0x7b, 0x01, 0x24, 0x00, 0xf9, 0x74, 0x01, 0x3e,
0xfa, 0x12, 0x25, 0xb5, 0x75, 0x12, 0x00, 0xf5, 0x13, 0xf5, 0xa4, 0xe5,
0x12, 0xf5, 0xa5, 0x75, 0x9a, 0x0e, 0x90, 0x00, 0x5a, 0xe0, 0xfe, 0xa3,
0xe0, 0xff, 0x90, 0x00, 0x58, 0xe0, 0xb5, 0x06, 0x09, 0xa3, 0xe0, 0xb5,
0x07, 0x04, 0x7f, 0x01, 0x80, 0x02, 0xe4, 0xff, 0x12, 0x78, 0x79, 0x90,
0x00, 0x58, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x4e, 0x70, 0x06, 0x7e, 0x02,
0x7f, 0xf7, 0x80, 0x08, 0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe,
0x90, 0x00, 0x58, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xe4, 0x90, 0x00,
0x65, 0xf0, 0x90, 0x00, 0x5a, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0x58, 0xf0,
0xa3, 0xf0, 0x7e, 0x02, 0x7f, 0xf8, 0xfd, 0x7b, 0x01, 0x7a, 0x01, 0x79,
0x00, 0x12, 0x26, 0xc1, 0x7f, 0x01, 0x02, 0x78, 0x79, 0x7f, 0x55, 0x80,
0x49, 0x90, 0x04, 0x11, 0xe0, 0xff, 0xd3, 0x94, 0x01, 0x40, 0x0f, 0x90,
0x00, 0x65, 0xe0, 0xc4, 0x54, 0xf0, 0x44, 0x40, 0xfe, 0xef, 0x4e, 0xff,
0x80, 0x30, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0xef, 0x30, 0xe2, 0x1c, 0x7f,
0xd9, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0x64, 0x01, 0x60, 0x10, 0x7f,
0xd9, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0xc4, 0x54, 0xf0, 0x44, 0x80,
0xff, 0x80, 0x0b, 0x90, 0x04, 0x49, 0xe0, 0xd3, 0x94, 0x01, 0x40, 0x05,
0x7f, 0xd2, 0x02, 0x78, 0x5a, 0x90, 0x04, 0x48, 0xe0, 0x70, 0x0c, 0x90,
0x04, 0x11, 0xe0, 0xd3, 0x94, 0x00, 0x50, 0x03, 0x02, 0x11, 0xdd, 0x90,
0x00, 0x65, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x11, 0xe0, 0xd3, 0x94, 0x00,
0x7f, 0x00, 0x40, 0x02, 0x7f, 0x01, 0x90, 0x04, 0x4e, 0xef, 0xf0, 0x90,
0x04, 0x11, 0x74, 0x04, 0xf0, 0x7f, 0x0d, 0x12, 0x78, 0xe6, 0xef, 0x90,
0x04, 0x17, 0xf0, 0x12, 0x49, 0xb8, 0x90, 0x04, 0x24, 0xe0, 0xfe, 0xa3,
0xe0, 0xf5, 0xa4, 0xee, 0xf5, 0xa5, 0x75, 0x9a, 0x0e, 0x02, 0x11, 0xc9,
0x90, 0x04, 0x3f, 0x74, 0x01, 0xf0, 0xe4, 0x90, 0x00, 0x5a, 0xf0, 0xa3,
0xf0, 0x90, 0x00, 0x58, 0xf0, 0xa3, 0xf0, 0x7e, 0x02, 0x7f, 0xf8, 0xfd,
0x7b, 0x01, 0x7a, 0x01, 0x79, 0x00, 0x12, 0x26, 0xc1, 0xe4, 0x90, 0x00,
0x65, 0xf0, 0x12, 0x74, 0xb2, 0x90, 0x04, 0x4e, 0xe0, 0xd3, 0x64, 0x80,
0x94, 0x80, 0x7f, 0x00, 0x40, 0x02, 0x7f, 0x01, 0x90, 0x04, 0x11, 0x80,
0x53, 0x75, 0xf0, 0x02, 0xe5, 0x38, 0xa4, 0x24, 0xf8, 0xf5, 0x82, 0xe5,
0xf0, 0x34, 0x7b, 0xf5, 0x83, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0xff,
0x90, 0x04, 0x16, 0xe0, 0xfd, 0x7c, 0x00, 0xef, 0x2d, 0xff, 0xec, 0x3e,
0xfe, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0x74, 0x01, 0x3e, 0xf5, 0x83, 0xe0,
0x75, 0x12, 0x00, 0xf5, 0x13, 0xf5, 0xa4, 0xe5, 0x12, 0xf5, 0xa5, 0x75,
0x9a, 0x0e, 0x90, 0x04, 0x16, 0xe0, 0xff, 0xc3, 0x94, 0xbf, 0x40, 0x06,
0x7e, 0x00, 0x7f, 0x00, 0x80, 0x03, 0xef, 0x04, 0xff, 0x90, 0x04, 0x16,
0xef, 0xf0, 0x02, 0x11, 0xda, 0x75, 0xf0, 0x02, 0xe5, 0x38, 0xa4, 0x24,
0xf8, 0xf5, 0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83, 0xe4, 0x93, 0xfe,
0x74, 0x01, 0x93, 0xff, 0x90, 0x04, 0x16, 0xe0, 0xf9, 0xfd, 0x7c, 0x00,
0xef, 0x2d, 0xff, 0xec, 0x3e, 0xfe, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0x74,
0x01, 0x3e, 0xf5, 0x83, 0xe0, 0xfd, 0xe9, 0xc3, 0x94, 0xbf, 0x40, 0x04,
0x79, 0x00, 0x80, 0x06, 0x90, 0x04, 0x16, 0xe0, 0x04, 0xf9, 0x90, 0x04,
0x16, 0xe9, 0xf0, 0x75, 0xf0, 0x02, 0xe5, 0x38, 0xa4, 0x24, 0xf8, 0xf5,
0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83, 0xe4, 0x93, 0xfe, 0x74, 0x01,
0x93, 0xff, 0xe9, 0xfb, 0x7a, 0x00, 0xef, 0x2b, 0xff, 0xea, 0x3e, 0xfe,
0x74, 0x00, 0x2f, 0xf5, 0x82, 0x74, 0x01, 0x3e, 0xf5, 0x83, 0xe0, 0x75,
0x12, 0x00, 0xf5, 0x13, 0xe9, 0xc3, 0x94, 0xbf, 0x40, 0x04, 0x7f, 0x00,
0x80, 0x06, 0x90, 0x04, 0x16, 0xe0, 0x04, 0xff, 0x90, 0x04, 0x16, 0xef,
0xf0, 0xaf, 0x05, 0xe5, 0x13, 0xf5, 0xa4, 0xed, 0x45, 0x12, 0xfe, 0xee,
0xf5, 0xa5, 0x75, 0x9a, 0x0e, 0x80, 0x0f, 0x12, 0x6d, 0x59, 0xef, 0xf5,
0xa4, 0x12, 0x6d, 0x59, 0xee, 0xf5, 0xa5, 0x75, 0x9a, 0x0e, 0x12, 0x78,
0xcd, 0x22, 0xe4, 0xf5, 0x1a, 0x90, 0x04, 0x14, 0xe0, 0x30, 0xe7, 0x03,
0x02, 0x15, 0xc2, 0x75, 0xa4, 0x20, 0x75, 0xa6, 0xdf, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x11, 0x90, 0x04, 0x49, 0xe0, 0x70, 0x12, 0xfb, 0x7a, 0x00,
0x79, 0x1a, 0x12, 0x6a, 0xde, 0x8f, 0x15, 0x8e, 0x14, 0x8d, 0x13, 0x8c,
0x12, 0x80, 0x72, 0x90, 0x04, 0x24, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xc3,
0x94, 0xf0, 0xee, 0x64, 0x80, 0x94, 0x7f, 0x40, 0x0b, 0xd3, 0xef, 0x94,
0x0f, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40, 0x07, 0x90, 0x04, 0x17, 0xe0,
0x20, 0xe1, 0x1c, 0x7f, 0x34, 0x12, 0x78, 0xb8, 0xee, 0x33, 0x95, 0xe0,
0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xc0, 0x04, 0xc0, 0x05, 0xc0,
0x06, 0xc0, 0x07, 0x7f, 0x35, 0x80, 0x1a, 0x7f, 0x36, 0x12, 0x78, 0xb8,
0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xc0,
0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x37, 0x12, 0x78, 0xeb,
0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xeb, 0x4f, 0xf5, 0x15,
0xea, 0xf5, 0x14, 0xe9, 0xf5, 0x13, 0xe8, 0xf5, 0x12, 0x7b, 0x00, 0x7a,
0x00, 0x79, 0x16, 0x12, 0x57, 0x08, 0x75, 0x1b, 0x00, 0x8f, 0x1c, 0x90,
0x04, 0x38, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xe4, 0xfc, 0xfd, 0x78, 0x10,
0x12, 0x26, 0x4e, 0xa8, 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xab, 0x07, 0xa3,
0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xeb, 0x4f, 0xff, 0xea, 0x4e, 0xfe, 0xe9,
0xfd, 0xe8, 0xfc, 0xef, 0x25, 0x15, 0xff, 0xee, 0x35, 0x14, 0xfe, 0xed,
0x35, 0x13, 0xfd, 0xec, 0x35, 0x12, 0xfc, 0xab, 0x15, 0xaa, 0x14, 0xa9,
0x13, 0xa8, 0x12, 0xd3, 0x12, 0x26, 0x2a, 0x40, 0x08, 0x74, 0xff, 0xff,
0xfe, 0xfd, 0xfc, 0x80, 0x38, 0x90, 0x04, 0x38, 0xe0, 0xfe, 0xa3, 0xe0,
0xff, 0xe4, 0xfc, 0xfd, 0x78, 0x10, 0x12, 0x26, 0x4e, 0xa8, 0x04, 0xa9,
0x05, 0xaa, 0x06, 0xab, 0x07, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xeb,
0x4f, 0xff, 0xea, 0x4e, 0xfe, 0xe9, 0xfd, 0xe8, 0xfc, 0xef, 0x25, 0x15,
0xff, 0xee, 0x35, 0x14, 0xfe, 0xed, 0x35, 0x13, 0xfd, 0xec, 0x35, 0x12,
0xfc, 0x8f, 0x15, 0x8e, 0x14, 0x8d, 0x13, 0x8c, 0x12, 0xe5, 0x1c, 0x64,
0x01, 0x45, 0x1b, 0x60, 0x0a, 0x90, 0x04, 0x24, 0xe0, 0x70, 0x02, 0xa3,
0xe0, 0x70, 0x2e, 0x12, 0x4e, 0x7f, 0xe5, 0x1a, 0x70, 0x04, 0x7f, 0x01,
0x80, 0x02, 0x7f, 0x00, 0xef, 0xc4, 0x33, 0x33, 0x54, 0xc0, 0x44, 0x80,
0xfc, 0xe5, 0x1c, 0xc4, 0x33, 0x54, 0xe0, 0x4c, 0xfe, 0x90, 0x04, 0x77,
0xe0, 0xfd, 0xed, 0xff, 0x90, 0x04, 0x14, 0xee, 0xf0, 0xa3, 0xef, 0xf0,
0x22, 0x90, 0x00, 0x62, 0xe0, 0xff, 0xe4, 0xfc, 0xfd, 0xfe, 0x78, 0x04,
0x12, 0x26, 0x4e, 0xab, 0x15, 0xaa, 0x14, 0xa9, 0x13, 0xa8, 0x12, 0xd3,
0x12, 0x26, 0x2a, 0x50, 0x03, 0x02, 0x15, 0x76, 0xe4, 0xff, 0x7e, 0x27,
0xfd, 0xfc, 0xab, 0x19, 0xaa, 0x18, 0xa9, 0x17, 0xa8, 0x16, 0xd3, 0x12,
0x26, 0x2a, 0x50, 0x1f, 0xe4, 0x7f, 0xcc, 0x7e, 0x07, 0xfd, 0xfc, 0xa8,
0x16, 0x12, 0x26, 0x2a, 0x50, 0x03, 0x02, 0x15, 0x76, 0x90, 0x04, 0x17,
0xe0, 0x54, 0x40, 0xd3, 0x94, 0x00, 0x50, 0x03, 0x02, 0x15, 0x76, 0x12,
0x4e, 0x7f, 0x90, 0x04, 0x17, 0xe0, 0x54, 0x01, 0xd3, 0x94, 0x00, 0x40,
0x1e, 0x90, 0x04, 0x24, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xee, 0x64, 0x80,
0x94, 0x80, 0x50, 0x09, 0xef, 0x24, 0x01, 0xff, 0xe4, 0x3e, 0xfe, 0x80,
0x26, 0x7e, 0x00, 0x7f, 0x00, 0x80, 0x20, 0x90, 0x04, 0x24, 0xe0, 0xfe,
0xa3, 0xe0, 0xff, 0xd3, 0x94, 0x00, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40,
0x0a, 0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0x80, 0x04, 0x7e,
0x00, 0x7f, 0x00, 0x90, 0x04, 0x24, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x90,
0x04, 0x17, 0xe0, 0xff, 0x54, 0x02, 0xd3, 0x94, 0x00, 0x50, 0x03, 0x02,
0x14, 0x97, 0x90, 0x04, 0x49, 0xe0, 0x60, 0x70, 0xef, 0x54, 0x04, 0xd3,
0x94, 0x00, 0x40, 0x02, 0x80, 0x66, 0x90, 0x04, 0x17, 0xe0, 0x54, 0x01,
0xd3, 0x94, 0x00, 0x40, 0x2d, 0x90, 0x04, 0x24, 0xe0, 0xf4, 0x70, 0x04,
0xa3, 0xe0, 0x64, 0xf0, 0x70, 0x12, 0x7f, 0xc1, 0x12, 0x6e, 0xc9, 0x7f,
0x01, 0x12, 0x6e, 0xc9, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x80, 0x2a,
0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a, 0x04,
0x80, 0x2e, 0x90, 0x04, 0x24, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x0f,
0x70, 0x16, 0x7f, 0x3f, 0x12, 0x6e, 0xc9, 0x7f, 0xff, 0x12, 0x6e, 0xc9,
0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x02, 0x15, 0x46,
0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a, 0x04,
0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a, 0x04,
0x02, 0x15, 0x46, 0x90, 0x04, 0x17, 0xe0, 0xff, 0x54, 0x04, 0xd3, 0x94,
0x00, 0x50, 0x03, 0x02, 0x15, 0x3d, 0xef, 0xc4, 0x54, 0x03, 0x14, 0x60,
0x49, 0x14, 0x60, 0x59, 0x14, 0x60, 0x69, 0x24, 0x03, 0x60, 0x03, 0x02,
0x15, 0x46, 0x90, 0x04, 0x26, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xc3, 0x94,
0x04, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40, 0x0a, 0xee, 0xa2, 0xe7, 0x13,
0xef, 0x13, 0x7e, 0x00, 0x80, 0x06, 0x7e, 0x00, 0x90, 0x04, 0x27, 0xe0,
0x54, 0x01, 0xff, 0xc3, 0x90, 0x04, 0x27, 0xe0, 0x94, 0x04, 0x90, 0x04,
0x26, 0xe0, 0x64, 0x80, 0x94, 0x80, 0x7d, 0x00, 0x40, 0x02, 0x7d, 0x01,
0x80, 0x42, 0x90, 0x04, 0x17, 0xe0, 0x54, 0x01, 0xd3, 0x94, 0x00, 0x7f,
0x00, 0x40, 0x02, 0x7f, 0x01, 0xe4, 0xfd, 0x80, 0x2f, 0x90, 0x04, 0x17,
0xe0, 0x54, 0x01, 0xd3, 0x94, 0x00, 0x7f, 0x00, 0x40, 0x02, 0x7f, 0x01,
0x7d, 0x01, 0x80, 0x1c, 0x90, 0x04, 0x26, 0xe0, 0xa2, 0xe7, 0x13, 0xa3,
0xe0, 0x13, 0x54, 0x01, 0xff, 0x7d, 0x01, 0x12, 0x4c, 0x24, 0x90, 0x04,
0x26, 0xa3, 0xe0, 0x54, 0x01, 0xff, 0xe4, 0xfd, 0x12, 0x4c, 0x24, 0x80,
0x09, 0x90, 0x04, 0x24, 0xa3, 0xe0, 0xff, 0x12, 0x73, 0x80, 0x12, 0x77,
0x83, 0xe4, 0x90, 0x04, 0x38, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0,
0x12, 0x75, 0x3a, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x1a, 0x12, 0x6a, 0xde,
0x8f, 0x15, 0x8e, 0x14, 0x8d, 0x13, 0x8c, 0x12, 0xe4, 0xf5, 0xa4, 0x75,
0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x11, 0x80, 0x2c, 0xaf, 0x15,
0xae, 0x14, 0xad, 0x13, 0xac, 0x12, 0x78, 0x10, 0x12, 0x26, 0x3b, 0x90,
0x04, 0x38, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0xa3, 0xe5, 0x14, 0xf0, 0xa3,
0xe5, 0x15, 0xf0, 0x12, 0x75, 0x3a, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xdf,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x11, 0x90, 0x04, 0x24, 0xa3, 0xe0, 0x54,
0x7f, 0xf5, 0x1b, 0x75, 0x1c, 0x00, 0x90, 0x04, 0x77, 0xe0, 0xff, 0xe5,
0x1b, 0xfe, 0xe5, 0x1c, 0x4f, 0xff, 0x90, 0x04, 0x14, 0xee, 0xf0, 0xa3,
0xef, 0xf0, 0x22, 0x8f, 0x12, 0x75, 0x14, 0xe1, 0x75, 0x15, 0x1f, 0x75,
0x13, 0xff, 0xd3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80, 0x40, 0x1c, 0x7f,
0x46, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20,
0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33, 0x95, 0xe0, 0x8f, 0x16, 0x7f,
0x45, 0x80, 0x3f, 0xc3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80, 0x50, 0x1c,
0x7f, 0x48, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d,
0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33, 0x95, 0xe0, 0x8f, 0x16,
0x7f, 0x47, 0x80, 0x1a, 0x7f, 0x44, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f,
0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33,
0x95, 0xe0, 0x8f, 0x16, 0x7f, 0x43, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f,
0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33,
0x95, 0xe0, 0x8f, 0x17, 0x90, 0x04, 0x53, 0xe0, 0x60, 0x03, 0x02, 0x17,
0x90, 0x7f, 0x34, 0x12, 0x78, 0xb8, 0x8e, 0x1a, 0x8f, 0x1b, 0x90, 0x04,
0x4e, 0xe0, 0xfb, 0x90, 0x04, 0x1c, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5,
0x21, 0x85, 0x14, 0x22, 0x85, 0x15, 0x23, 0x85, 0x13, 0x24, 0xad, 0x1b,
0xac, 0x1a, 0xaf, 0x16, 0x12, 0x55, 0x56, 0x8f, 0x18, 0x90, 0x04, 0x62,
0xe0, 0x60, 0x4d, 0x90, 0x04, 0x4e, 0xe0, 0xfb, 0x90, 0x04, 0x1c, 0xe0,
0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0x85, 0x14, 0x22, 0x85, 0x15, 0x23,
0x85, 0x18, 0x24, 0xad, 0x1b, 0xac, 0x1a, 0xaf, 0x16, 0x12, 0x43, 0x1d,
0x90, 0x04, 0x51, 0xef, 0xf0, 0xd3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80,
0x40, 0x07, 0xe0, 0x90, 0x04, 0x67, 0xf0, 0x80, 0x17, 0xc3, 0xe5, 0x12,
0x64, 0x80, 0x94, 0x80, 0x90, 0x04, 0x51, 0xe0, 0x50, 0x06, 0x90, 0x04,
0x65, 0xf0, 0x80, 0x04, 0x90, 0x04, 0x63, 0xf0, 0x90, 0x04, 0x4e, 0xe5,
0x16, 0xf0, 0x90, 0x04, 0x1c, 0xe5, 0x1a, 0xf0, 0xa3, 0xe5, 0x1b, 0xf0,
0x90, 0x04, 0x62, 0xe0, 0x90, 0x04, 0x53, 0xf0, 0xd3, 0xe5, 0x12, 0x64,
0x80, 0x94, 0x80, 0x40, 0x14, 0xaf, 0x18, 0xef, 0x33, 0x95, 0xe0, 0xef,
0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x46, 0x80,
0x2f, 0xc3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80, 0x50, 0x14, 0xaf, 0x18,
0xef, 0x33, 0x95, 0xe0, 0xef, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0x48, 0x80, 0x12, 0xaf, 0x18, 0xef, 0x33, 0x95, 0xe0,
0xef, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x44,
0x90, 0x04, 0x62, 0xe0, 0x60, 0x56, 0xd3, 0xe5, 0x12, 0x64, 0x80, 0x94,
0x80, 0x40, 0x12, 0x7d, 0x05, 0x7f, 0x20, 0x12, 0x70, 0x9f, 0x90, 0x04,
0x61, 0xe0, 0xfb, 0x7d, 0x05, 0x7f, 0x20, 0x80, 0x36, 0xc3, 0xe5, 0x12,
0x64, 0x80, 0x94, 0x80, 0x90, 0x04, 0x60, 0xe0, 0xfb, 0x7a, 0x00, 0x50,
0x14, 0x7d, 0x01, 0x7f, 0x02, 0x7e, 0x00, 0x12, 0x70, 0xa8, 0x90, 0x04,
0x61, 0xe0, 0xfb, 0x7d, 0x01, 0x7f, 0x02, 0x80, 0x12, 0x7d, 0x03, 0x7f,
0x08, 0x7e, 0x00, 0x12, 0x70, 0xa8, 0x90, 0x04, 0x61, 0xe0, 0xfb, 0x7d,
0x03, 0x7f, 0x08, 0x7e, 0x00, 0x12, 0x71, 0xbb, 0x90, 0x04, 0x54, 0xe0,
0x60, 0x03, 0x02, 0x18, 0xcc, 0x7f, 0x36, 0x12, 0x78, 0xb8, 0x8e, 0x1a,
0x8f, 0x1b, 0x90, 0x04, 0x4f, 0xe0, 0xfb, 0x90, 0x04, 0x1e, 0xe0, 0xf5,
0x20, 0xa3, 0xe0, 0xf5, 0x21, 0x85, 0x14, 0x22, 0x85, 0x15, 0x23, 0x85,
0x13, 0x24, 0xad, 0x1b, 0xac, 0x1a, 0xaf, 0x17, 0x12, 0x55, 0x56, 0x8f,
0x19, 0x90, 0x04, 0x62, 0xe0, 0x60, 0x4d, 0x90, 0x04, 0x4f, 0xe0, 0xfb,
0x90, 0x04, 0x1e, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0x85, 0x14,
0x22, 0x85, 0x15, 0x23, 0x85, 0x19, 0x24, 0xad, 0x1b, 0xac, 0x1a, 0xaf,
0x17, 0x12, 0x43, 0x1d, 0x90, 0x04, 0x50, 0xef, 0xf0, 0xd3, 0xe5, 0x12,
0x64, 0x80, 0x94, 0x80, 0x40, 0x07, 0xe0, 0x90, 0x04, 0x68, 0xf0, 0x80,
0x17, 0xc3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80, 0x90, 0x04, 0x50, 0xe0,
0x50, 0x06, 0x90, 0x04, 0x66, 0xf0, 0x80, 0x04, 0x90, 0x04, 0x64, 0xf0,
0x90, 0x04, 0x4f, 0xe5, 0x17, 0xf0, 0x90, 0x04, 0x1e, 0xe5, 0x1a, 0xf0,
0xa3, 0xe5, 0x1b, 0xf0, 0x90, 0x04, 0x62, 0xe0, 0x90, 0x04, 0x54, 0xf0,
0xd3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80, 0x40, 0x10, 0xaf, 0x19, 0xef,
0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x45, 0x80,
0x27, 0xc3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80, 0x50, 0x10, 0xaf, 0x19,
0xef, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x47,
0x80, 0x0e, 0xaf, 0x19, 0xef, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0x43, 0x90, 0x04, 0x62, 0xe0, 0x60, 0x56, 0xd3, 0xe5,
0x12, 0x64, 0x80, 0x94, 0x80, 0x40, 0x12, 0x7d, 0x04, 0x7f, 0x10, 0x12,
0x70, 0x9f, 0x90, 0x04, 0x61, 0xe0, 0xfb, 0x7d, 0x04, 0x7f, 0x10, 0x80,
0x36, 0xc3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x80, 0x90, 0x04, 0x60, 0xe0,
0xfb, 0x7a, 0x00, 0x50, 0x14, 0xe4, 0xfd, 0x7f, 0x01, 0xfe, 0x12, 0x70,
0xa8, 0x90, 0x04, 0x61, 0xe0, 0xfb, 0xe4, 0xfd, 0x7f, 0x01, 0xfe, 0x80,
0x14, 0x7d, 0x02, 0x7f, 0x04, 0x7e, 0x00, 0x12, 0x70, 0xa8, 0x90, 0x04,
0x61, 0xe0, 0xfb, 0x7d, 0x02, 0x7f, 0x04, 0x7e, 0x00, 0x12, 0x71, 0xbb,
0x90, 0x04, 0x53, 0xe0, 0x60, 0x0b, 0xa3, 0xe0, 0x60, 0x07, 0x90, 0x04,
0x4d, 0x74, 0x01, 0xf0, 0x22, 0xe4, 0x90, 0x04, 0x4d, 0xf0, 0x22, 0x90,
0x04, 0x50, 0xe0, 0xff, 0xa3, 0xe0, 0xfd, 0x8f, 0x12, 0x8d, 0x13, 0x90,
0x04, 0x49, 0xe0, 0xb4, 0x01, 0x04, 0x7f, 0x34, 0x80, 0x5d, 0x90, 0x00,
0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x7e, 0x00, 0x54, 0x1f, 0xff,
0xd3, 0x94, 0x10, 0xee, 0x94, 0x00, 0x40, 0x45, 0x90, 0x04, 0x7f, 0xe0,
0xfd, 0xc4, 0x54, 0x0f, 0x20, 0xe0, 0x09, 0xd3, 0xef, 0x94, 0x16, 0xee,
0x94, 0x00, 0x40, 0x31, 0xe5, 0x12, 0xb4, 0x01, 0x0b, 0x90, 0x04, 0x88,
0xe0, 0xc4, 0x13, 0x54, 0x07, 0x30, 0xe0, 0x12, 0xe5, 0x12, 0x64, 0x02,
0x70, 0x1b, 0x90, 0x04, 0x88, 0xe0, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x20,
0xe0, 0x0f, 0xe5, 0x13, 0x70, 0x04, 0x7f, 0x34, 0x80, 0x02, 0x7f, 0x36,
0x12, 0x78, 0xb8, 0x80, 0x05, 0x7f, 0x38, 0x12, 0x78, 0xb8, 0x8e, 0x14,
0x8f, 0x15, 0x12, 0x78, 0xf0, 0xef, 0x60, 0x10, 0xe5, 0x12, 0xb4, 0x04,
0x03, 0x75, 0x12, 0x05, 0xe5, 0x12, 0xb4, 0x05, 0x03, 0x75, 0x12, 0x04,
0xe5, 0x12, 0x24, 0xfe, 0x60, 0x62, 0x14, 0x70, 0x03, 0x02, 0x1a, 0x93,
0x14, 0x70, 0x03, 0x02, 0x1a, 0xaf, 0x14, 0x70, 0x03, 0x02, 0x1a, 0xcc,
0x24, 0x04, 0x60, 0x03, 0x02, 0x1a, 0xe7, 0xe5, 0x13, 0x7f, 0x3b, 0x70,
0x1c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0xc0, 0x06,
0xc0, 0x07, 0x7f, 0x3b, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x3f, 0x13, 0x13,
0x13, 0x54, 0x1f, 0x80, 0x15, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff,
0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3b, 0x12, 0x78, 0xe6, 0xef,
0x54, 0x07, 0xfd, 0xd0, 0xe0, 0x2d, 0xff, 0xd0, 0xe0, 0x8f, 0x16, 0xe4,
0xf5, 0x18, 0x75, 0x17, 0x46, 0x02, 0x1a, 0xea, 0xe5, 0x13, 0x70, 0x5b,
0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x7f, 0xc4, 0x13, 0x13, 0x54,
0x03, 0x7f, 0x3c, 0x60, 0x27, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x1f, 0xff,
0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef,
0x54, 0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f, 0xfd, 0xd0, 0xe0, 0x2d, 0xff,
0xd0, 0xe0, 0xc3, 0xe4, 0x9f, 0xff, 0x80, 0x71, 0x12, 0x78, 0xeb, 0xef,
0x54, 0x1f, 0xff, 0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3c, 0x12,
0x78, 0xe6, 0xef, 0x54, 0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f, 0xfd, 0xd0,
0xe0, 0x2d, 0xff, 0xd0, 0xe0, 0x80, 0x4e, 0x7f, 0x3c, 0x12, 0x78, 0xeb,
0xef, 0x54, 0x3f, 0xc4, 0x13, 0x54, 0x07, 0x7f, 0x3c, 0x60, 0x22, 0x12,
0x78, 0xeb, 0xef, 0x54, 0x1f, 0xff, 0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07,
0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x07, 0xfd, 0xd0, 0xe0, 0x2d,
0xff, 0xd0, 0xe0, 0xc3, 0xe4, 0x9f, 0xff, 0x80, 0x1c, 0x12, 0x78, 0xeb,
0xef, 0x54, 0x1f, 0xff, 0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3c,
0x12, 0x78, 0xe6, 0xef, 0x54, 0x07, 0xfd, 0xd0, 0xe0, 0x2d, 0xff, 0xd0,
0xe0, 0x8f, 0x16, 0x75, 0x18, 0xda, 0x75, 0x17, 0x26, 0x80, 0x57, 0x7f,
0x3d, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20,
0x7c, 0x00, 0x12, 0x77, 0xe0, 0x8f, 0x16, 0x75, 0x18, 0xe1, 0x75, 0x17,
0x1f, 0x80, 0x3b, 0x7f, 0x3d, 0x12, 0x78, 0xb8, 0xee, 0x54, 0x07, 0xfe,
0x7d, 0x00, 0x7c, 0x04, 0x12, 0x77, 0xe0, 0xef, 0x78, 0x06, 0xce, 0xa2,
0xe7, 0x13, 0xce, 0x13, 0xd8, 0xf8, 0x80, 0x10, 0x7f, 0x3d, 0x12, 0x78,
0xb8, 0xef, 0x78, 0x0b, 0xce, 0xa2, 0xe7, 0x13, 0xce, 0x13, 0xd8, 0xf8,
0xff, 0x8f, 0x16, 0x75, 0x18, 0xf1, 0x75, 0x17, 0x0f, 0x80, 0x03, 0xe4,
0xf5, 0x16, 0x90, 0x04, 0x4f, 0xe5, 0x16, 0xf0, 0x70, 0x04, 0xfe, 0xff,
0x80, 0x13, 0xc3, 0xe5, 0x16, 0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0x7e,
0x00, 0x7f, 0x01, 0x80, 0x04, 0x7e, 0xff, 0x7f, 0xff, 0xc3, 0xe5, 0x15,
0x9f, 0xf5, 0x15, 0xe5, 0x14, 0x9e, 0xf5, 0x14, 0x90, 0x04, 0x4b, 0xe0,
0xd3, 0x94, 0x00, 0x40, 0x2b, 0x90, 0x04, 0x4e, 0xe0, 0xfb, 0x90, 0x04,
0x1e, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0x85, 0x18, 0x22, 0x85,
0x17, 0x23, 0x75, 0x24, 0xff, 0xad, 0x15, 0xac, 0x14, 0xaf, 0x16, 0x12,
0x55, 0x56, 0x8f, 0x16, 0x90, 0x04, 0x62, 0xe0, 0x90, 0x04, 0x4d, 0xf0,
0xe5, 0x12, 0xb4, 0x01, 0x1f, 0xe5, 0x16, 0xb5, 0x18, 0x15, 0xc3, 0xe5,
0x15, 0x94, 0xff, 0xe5, 0x14, 0x64, 0x80, 0x94, 0x7f, 0x50, 0x08, 0x90,
0x04, 0x7c, 0x74, 0x01, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0x04, 0x7c, 0xf0,
0x90, 0x04, 0x4c, 0xe0, 0x64, 0x01, 0x60, 0x08, 0x90, 0x04, 0x4a, 0xe0,
0x64, 0x03, 0x70, 0x31, 0xe5, 0x12, 0xb4, 0x01, 0x06, 0xe5, 0x16, 0x65,
0x17, 0x60, 0x13, 0xe5, 0x12, 0xd3, 0x94, 0x01, 0x40, 0x1f, 0xe5, 0x16,
0x65, 0x17, 0x60, 0x06, 0xe5, 0x16, 0x65, 0x18, 0x70, 0x13, 0x75, 0xa4,
0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x19, 0x7d, 0x01,
0x7f, 0x1c, 0x12, 0x34, 0x1e, 0x90, 0x04, 0x49, 0xe0, 0xb4, 0x01, 0x09,
0xad, 0x16, 0xaf, 0x12, 0x12, 0x2e, 0x0a, 0x80, 0x0f, 0x90, 0x04, 0x4f,
0xe0, 0xf5, 0x1c, 0xab, 0x16, 0xad, 0x13, 0xaf, 0x12, 0x12, 0x1b, 0xe5,
0x90, 0x04, 0x1e, 0xe5, 0x14, 0xf0, 0xa3, 0xe5, 0x15, 0xf0, 0x90, 0x04,
0x4f, 0xe0, 0x90, 0x04, 0x4e, 0xf0, 0x90, 0x04, 0x4b, 0xe0, 0x04, 0xf0,
0x22, 0x8f, 0x19, 0x8d, 0x1a, 0x8b, 0x1b, 0xc3, 0xe5, 0x1b, 0x95, 0x1c,
0xf5, 0x1d, 0xe5, 0x19, 0x24, 0xfe, 0x70, 0x03, 0x02, 0x1d, 0x08, 0x04,
0x60, 0x03, 0x02, 0x1e, 0xd9, 0x7f, 0x3b, 0x12, 0x78, 0xe6, 0xef, 0x54,
0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f, 0xf5, 0x20, 0x7f, 0x3b, 0x12, 0x78,
0xe6, 0xef, 0x54, 0x07, 0xf5, 0x21, 0x7f, 0x3b, 0x12, 0x78, 0xeb, 0xef,
0x54, 0x3f, 0xf5, 0x22, 0x75, 0x23, 0x3f, 0xe5, 0x1a, 0x14, 0x60, 0x69,
0x04, 0x60, 0x03, 0x02, 0x1c, 0xba, 0x78, 0x27, 0x7c, 0x00, 0x7d, 0x00,
0x7b, 0x00, 0x7a, 0x00, 0x79, 0x1e, 0x7e, 0x00, 0x7f, 0x06, 0x12, 0x25,
0x6d, 0x7d, 0x01, 0xaf, 0x1d, 0x12, 0x6d, 0xba, 0xc0, 0x03, 0x78, 0x1e,
0x7c, 0x00, 0x1d, 0xd0, 0x03, 0x7e, 0x00, 0x7f, 0x06, 0x12, 0x25, 0x6d,
0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x7e, 0x00, 0x54,
0x1f, 0xff, 0xd3, 0x94, 0x10, 0xee, 0x94, 0x00, 0x40, 0x1e, 0x90, 0x04,
0x7f, 0xe0, 0xc4, 0x54, 0x0f, 0x20, 0xe0, 0x09, 0xd3, 0xef, 0x94, 0x16,
0xee, 0x94, 0x00, 0x40, 0x0b, 0x90, 0x04, 0x88, 0xe0, 0xc4, 0x13, 0x54,
0x07, 0x30, 0xe0, 0x2a, 0x85, 0x20, 0x21, 0x80, 0x25, 0x78, 0x27, 0x7c,
0x00, 0x7d, 0x00, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x1e, 0x7e, 0x00, 0x7f,
0x06, 0x12, 0x25, 0x6d, 0xe4, 0xfd, 0xaf, 0x1d, 0x12, 0x6d, 0xba, 0x78,
0x1e, 0x7c, 0x00, 0x7e, 0x00, 0x7f, 0x06, 0x12, 0x25, 0x6d, 0xaf, 0x21,
0xad, 0x07, 0xed, 0xf5, 0xa4, 0x74, 0x04, 0xf5, 0xa5, 0x75, 0xa7, 0xc0,
0x75, 0x9a, 0x2b, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f,
0x75, 0x9a, 0x2b, 0xaf, 0x20, 0xad, 0x07, 0xed, 0xf5, 0xa4, 0x74, 0x06,
0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75, 0xa5, 0x80, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0xaf, 0x22, 0xad, 0x07,
0xed, 0xf5, 0xa4, 0x74, 0x02, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a,
0x2b, 0x02, 0x1e, 0xcc, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x7f,
0xc4, 0x13, 0x13, 0x54, 0x03, 0xf5, 0x1e, 0x7f, 0x3c, 0x12, 0x78, 0xeb,
0xef, 0x54, 0x3f, 0xc4, 0x13, 0x54, 0x07, 0xf5, 0x1f, 0x7f, 0x3c, 0x12,
0x78, 0xe6, 0xef, 0x54, 0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f, 0xf5, 0x20,
0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x07, 0xf5, 0x21, 0x7f, 0x3c,
0x12, 0x78, 0xeb, 0xef, 0x54, 0x1f, 0xf5, 0x22, 0x75, 0x23, 0x1f, 0xe5,
0x1a, 0x14, 0x70, 0x03, 0x02, 0x1d, 0xf1, 0x04, 0x60, 0x03, 0x02, 0x1e,
0x47, 0xe5, 0x20, 0x25, 0x22, 0xff, 0xe4, 0x33, 0x4f, 0x70, 0x08, 0xe5,
0x1d, 0xb4, 0xff, 0x03, 0x75, 0x1e, 0x01, 0xaf, 0x1e, 0x7e, 0x00, 0x7c,
0xff, 0x7d, 0xfe, 0x12, 0x26, 0x02, 0xef, 0x04, 0x85, 0x1d, 0xf0, 0xa4,
0xf5, 0x24, 0x78, 0x27, 0x7c, 0x00, 0x7d, 0x00, 0x7b, 0x00, 0x7a, 0x00,
0x79, 0x1e, 0x7e, 0x00, 0x7f, 0x06, 0x12, 0x25, 0x6d, 0x7d, 0x01, 0xaf,
0x24, 0x12, 0x6d, 0xba, 0xc0, 0x03, 0x78, 0x1e, 0x7c, 0x00, 0x1d, 0xd0,
0x03, 0x7e, 0x00, 0x7f, 0x06, 0x12, 0x25, 0x6d, 0xe5, 0x20, 0x25, 0x22,
0xff, 0xe4, 0x33, 0x4f, 0x70, 0x02, 0xf5, 0x1e, 0x90, 0x00, 0x50, 0xe0,
0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x7e, 0x00, 0x54, 0x1f, 0xff, 0xd3, 0x94,
0x10, 0xee, 0x94, 0x00, 0x40, 0x1f, 0x90, 0x04, 0x7f, 0xe0, 0xc4, 0x54,
0x0f, 0x20, 0xe0, 0x09, 0xd3, 0xef, 0x94, 0x16, 0xee, 0x94, 0x00, 0x40,
0x0c, 0x90, 0x04, 0x88, 0xe0, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x30, 0xe0,
0x5e, 0x85, 0x20, 0x21, 0x85, 0x1e, 0x1f, 0x80, 0x56, 0xe5, 0x21, 0x25,
0x22, 0xff, 0xe4, 0x33, 0x4f, 0x70, 0x08, 0xe5, 0x1d, 0xb4, 0xff, 0x03,
0x75, 0x1f, 0x01, 0xaf, 0x1f, 0x7e, 0x00, 0x7c, 0xff, 0x7d, 0xfe, 0x12,
0x26, 0x02, 0xef, 0x04, 0x85, 0x1d, 0xf0, 0xa4, 0xf5, 0x24, 0x78, 0x27,
0x7c, 0x00, 0x7d, 0x00, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x1e, 0x7e, 0x00,
0x7f, 0x06, 0x12, 0x25, 0x6d, 0xe4, 0xfd, 0xaf, 0x24, 0x12, 0x6d, 0xba,
0x78, 0x1e, 0x7c, 0x00, 0x7e, 0x00, 0x7f, 0x06, 0x12, 0x25, 0x6d, 0xe5,
0x21, 0x25, 0x22, 0xff, 0xe4, 0x33, 0x4f, 0x70, 0x02, 0xf5, 0x1f, 0xaf,
0x21, 0xad, 0x07, 0xed, 0xf5, 0xa4, 0x74, 0x0a, 0xf5, 0xa5, 0x75, 0xa7,
0xc0, 0x75, 0x9a, 0x2b, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7,
0x7f, 0x75, 0x9a, 0x2b, 0xaf, 0x20, 0xad, 0x07, 0xed, 0xf5, 0xa4, 0x74,
0x0c, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75, 0xa5, 0x80,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0xaf, 0x22, 0xad,
0x07, 0xed, 0xf5, 0xa4, 0x74, 0x08, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75,
0x9a, 0x2b, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75,
0x9a, 0x2b, 0xaf, 0x1e, 0xad, 0x07, 0xed, 0xf5, 0xa4, 0x74, 0x14, 0xf5,
0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75, 0xa5, 0x80, 0x75, 0xa6,
0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0xaf, 0x1f, 0xad, 0x07, 0xed,
0xf5, 0xa4, 0x74, 0x16, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b,
0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b,
0x22, 0xad, 0x1b, 0xaf, 0x19, 0x12, 0x2e, 0x0a, 0x22, 0x8f, 0x12, 0x75,
0x1a, 0x03, 0x90, 0x04, 0x49, 0xe0, 0x60, 0x09, 0x90, 0x04, 0x4d, 0x74,
0x01, 0xf0, 0x7f, 0x02, 0x22, 0xe4, 0xf5, 0x15, 0xf5, 0x13, 0xf5, 0x14,
0xf5, 0x17, 0xf5, 0x18, 0xf5, 0x19, 0xf5, 0x16, 0x7f, 0x38, 0x12, 0x78,
0xb8, 0x90, 0x04, 0x1c, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x7f, 0x39, 0x12,
0x78, 0xb8, 0xee, 0x54, 0x03, 0x90, 0x04, 0x1e, 0xf0, 0xa3, 0xef, 0xf0,
0x12, 0x78, 0x36, 0x90, 0x04, 0x51, 0xef, 0xf0, 0xe5, 0x12, 0xb4, 0x02,
0x05, 0x90, 0x04, 0x6f, 0x80, 0x1b, 0xe5, 0x12, 0xb4, 0x03, 0x05, 0x90,
0x04, 0x70, 0x80, 0x11, 0xe5, 0x12, 0xb4, 0x01, 0x05, 0x90, 0x04, 0x71,
0x80, 0x07, 0xe5, 0x12, 0x70, 0x06, 0x90, 0x04, 0x72, 0xe0, 0xf5, 0x16,
0xe4, 0xfd, 0x90, 0x04, 0x1c, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x25,
0x90, 0x04, 0x1e, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xd3, 0x94, 0x00, 0xee,
0x64, 0x80, 0x94, 0x80, 0x40, 0x3a, 0xee, 0xa2, 0xe7, 0x13, 0xfe, 0xef,
0x13, 0xff, 0x90, 0x04, 0x1e, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x0d, 0x80,
0xdb, 0x7d, 0x0a, 0x90, 0x04, 0x1c, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xd3,
0x94, 0x00, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40, 0x13, 0xee, 0xa2, 0xe7,
0x13, 0xfe, 0xef, 0x13, 0xff, 0x90, 0x04, 0x1c, 0xee, 0xf0, 0xa3, 0xef,
0xf0, 0x0d, 0x80, 0xdb, 0xed, 0x24, 0xfc, 0xf5, 0x15, 0xff, 0x33, 0x95,
0xe0, 0xfe, 0xef, 0x78, 0x07, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8, 0xf9,
0x78, 0x03, 0xce, 0xa2, 0xe7, 0x13, 0xce, 0x13, 0xd8, 0xf8, 0xfd, 0xac,
0x06, 0x90, 0x04, 0x22, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x03, 0xce, 0xc3,
0x13, 0xce, 0x13, 0xd8, 0xf9, 0xc3, 0x9d, 0xf5, 0x14, 0xee, 0x9c, 0xf5,
0x13, 0xe5, 0x12, 0xb4, 0x02, 0x0f, 0xd3, 0xe5, 0x14, 0x94, 0x00, 0xe5,
0x13, 0x64, 0x80, 0x94, 0x9f, 0x40, 0x02, 0x80, 0x39, 0xe5, 0x12, 0xb4,
0x03, 0x0f, 0xd3, 0xe5, 0x14, 0x94, 0x00, 0xe5, 0x13, 0x64, 0x80, 0x94,
0x9f, 0x40, 0x02, 0x80, 0x25, 0xe5, 0x12, 0xb4, 0x01, 0x0f, 0xd3, 0xe5,
0x14, 0x94, 0x00, 0xe5, 0x13, 0x64, 0x80, 0x94, 0x9f, 0x40, 0x02, 0x80,
0x11, 0xe5, 0x12, 0x70, 0x13, 0xd3, 0xe5, 0x14, 0x94, 0x00, 0xe5, 0x13,
0x64, 0x80, 0x94, 0x9f, 0x40, 0x06, 0x75, 0x13, 0x1f, 0x75, 0x14, 0x00,
0xe5, 0x14, 0xae, 0x13, 0x78, 0x03, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8,
0xf9, 0x90, 0x04, 0x23, 0xf0, 0xee, 0x90, 0x04, 0x22, 0xf0, 0xe5, 0x16,
0x75, 0xf0, 0x08, 0xa4, 0xae, 0xf0, 0x25, 0x14, 0xf5, 0x14, 0xee, 0x35,
0x13, 0xf5, 0x13, 0xe5, 0x12, 0xb4, 0x02, 0x0f, 0xd3, 0xe5, 0x14, 0x94,
0x00, 0xe5, 0x13, 0x64, 0x80, 0x94, 0x9f, 0x40, 0x02, 0x80, 0x39, 0xe5,
0x12, 0xb4, 0x03, 0x0f, 0xd3, 0xe5, 0x14, 0x94, 0x00, 0xe5, 0x13, 0x64,
0x80, 0x94, 0x9f, 0x40, 0x02, 0x80, 0x25, 0xe5, 0x12, 0xb4, 0x01, 0x0f,
0xd3, 0xe5, 0x14, 0x94, 0x00, 0xe5, 0x13, 0x64, 0x80, 0x94, 0x9f, 0x40,
0x02, 0x80, 0x11, 0xe5, 0x12, 0x70, 0x13, 0xd3, 0xe5, 0x14, 0x94, 0x00,
0xe5, 0x13, 0x64, 0x80, 0x94, 0x9f, 0x40, 0x06, 0x75, 0x13, 0x1f, 0x75,
0x14, 0x00, 0xae, 0x13, 0xe5, 0x14, 0x78, 0x03, 0xc3, 0x33, 0xce, 0x33,
0xce, 0xd8, 0xf9, 0xf5, 0x18, 0x8e, 0x17, 0xe5, 0x17, 0x54, 0x07, 0xfe,
0xe5, 0x18, 0x78, 0x03, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0xf5,
0x16, 0xe5, 0x12, 0x60, 0x03, 0xb4, 0x03, 0x0b, 0xe5, 0x17, 0x13, 0x13,
0x13, 0x54, 0x1f, 0xf5, 0x19, 0x80, 0x0d, 0xe5, 0x17, 0x13, 0x13, 0x13,
0x54, 0x1f, 0x75, 0xf0, 0xff, 0xa4, 0xf5, 0x19, 0xe5, 0x12, 0x60, 0x03,
0xb4, 0x01, 0x26, 0xd3, 0xe5, 0x19, 0x64, 0x80, 0x94, 0x9f, 0x40, 0x05,
0x90, 0x04, 0x51, 0x80, 0x2f, 0xc3, 0xe5, 0x19, 0x64, 0x80, 0x94, 0x61,
0x50, 0x05, 0x90, 0x04, 0x51, 0x80, 0x32, 0xe5, 0x19, 0x60, 0x3b, 0x90,
0x04, 0x51, 0xf0, 0x80, 0x35, 0xe5, 0x12, 0x64, 0x02, 0x60, 0x05, 0xe5,
0x12, 0xb4, 0x03, 0x2a, 0xd3, 0xe5, 0x19, 0x64, 0x80, 0x94, 0x9f, 0x40,
0x08, 0x90, 0x04, 0x50, 0x74, 0x1f, 0xf0, 0x80, 0x19, 0xc3, 0xe5, 0x19,
0x64, 0x80, 0x94, 0x61, 0x50, 0x08, 0x90, 0x04, 0x50, 0x74, 0xe1, 0xf0,
0x80, 0x08, 0xe5, 0x19, 0x60, 0x04, 0x90, 0x04, 0x50, 0xf0, 0x90, 0x04,
0x4d, 0x74, 0x01, 0xf0, 0xe5, 0x12, 0x70, 0x16, 0x90, 0x04, 0x22, 0xe0,
0x90, 0x04, 0x0f, 0xf0, 0x90, 0x04, 0x22, 0xa3, 0xe0, 0x90, 0x04, 0x75,
0xf0, 0x90, 0x04, 0x72, 0x80, 0x47, 0xe5, 0x12, 0xb4, 0x01, 0x16, 0x90,
0x04, 0x22, 0xe0, 0x90, 0x04, 0x10, 0xf0, 0x90, 0x04, 0x22, 0xa3, 0xe0,
0x90, 0x04, 0x76, 0xf0, 0x90, 0x04, 0x71, 0x80, 0x2c, 0xe5, 0x12, 0x90,
0x04, 0x22, 0xb4, 0x02, 0x13, 0xe0, 0x90, 0x04, 0x0d, 0xf0, 0x90, 0x04,
0x22, 0xa3, 0xe0, 0x90, 0x04, 0x73, 0xf0, 0x90, 0x04, 0x6f, 0x80, 0x11,
0xe0, 0x90, 0x04, 0x0e, 0xf0, 0x90, 0x04, 0x22, 0xa3, 0xe0, 0x90, 0x04,
0x74, 0xf0, 0x90, 0x04, 0x70, 0xe5, 0x16, 0xf0, 0x7f, 0x00, 0x22, 0x7f,
0x8b, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x0f, 0x90, 0x04, 0x49, 0xf0, 0x12,
0x76, 0xd2, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce,
0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x02, 0x80, 0x19, 0x90,
0x04, 0x49, 0xe0, 0x70, 0x18, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3,
0xe0, 0x13, 0x54, 0x1f, 0xc3, 0x94, 0x06, 0xe4, 0x94, 0x00, 0x40, 0x05,
0xe4, 0xf5, 0xa4, 0x80, 0x03, 0x75, 0xa4, 0x04, 0x75, 0xa6, 0xfb, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x40, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0,
0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x1e,
0x90, 0x04, 0x49, 0xe0, 0x70, 0x18, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13,
0xa3, 0xe0, 0x13, 0x54, 0x1f, 0xd3, 0x94, 0x0e, 0xe4, 0x94, 0x00, 0x40,
0x05, 0x75, 0xa4, 0x80, 0x80, 0x03, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0x7f,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x40, 0x90, 0x04, 0x00, 0xe0, 0xfc, 0xa3,
0xe0, 0xfd, 0xec, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0xed, 0xc4, 0x54, 0x0f,
0x48, 0x54, 0x03, 0x64, 0x02, 0x70, 0x0c, 0xed, 0xae, 0x04, 0x78, 0x02,
0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x90, 0x04, 0x00, 0xe0, 0xfe,
0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20,
0xe0, 0x03, 0x02, 0x23, 0x24, 0x75, 0xa5, 0x01, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xfe, 0x75, 0x9a, 0x40, 0x90, 0x04, 0x49, 0xe0, 0x60, 0x03, 0x02,
0x23, 0x48, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x7e,
0x00, 0x54, 0x1f, 0xff, 0xc3, 0x94, 0x0a, 0xee, 0x94, 0x00, 0x50, 0x03,
0x02, 0x23, 0x48, 0xef, 0x94, 0x0e, 0xee, 0x94, 0x00, 0x50, 0x11, 0x75,
0xa4, 0x01, 0x75, 0xa6, 0xfc, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x90, 0x75,
0xa5, 0x02, 0x80, 0x73, 0xc3, 0xef, 0x94, 0x12, 0xee, 0x94, 0x00, 0x50,
0x11, 0x75, 0xa4, 0x02, 0x75, 0xa6, 0xfc, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x90, 0x75, 0xa5, 0x04, 0x80, 0x59, 0x75, 0xa4, 0x03, 0x75, 0xa6, 0xfc,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x90, 0x75, 0xa5, 0x06, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0xf9, 0x75, 0x9a, 0x92, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13,
0xa3, 0xe0, 0x13, 0x54, 0x1f, 0xd3, 0x94, 0x15, 0xe4, 0x94, 0x00, 0x40,
0x05, 0x75, 0xa5, 0x20, 0x80, 0x03, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0xdf, 0x75, 0x9a, 0x90, 0x80, 0x24, 0xe4, 0xf5, 0xa5, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0xfe, 0x75, 0x9a, 0x40, 0xe4, 0xf5, 0xa4, 0x75,
0xa6, 0xfc, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x90, 0xe4, 0xf5, 0xa5, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0xf9, 0x75, 0x9a, 0x92, 0xe4, 0xf5, 0x12, 0xf5,
0x13, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x54, 0x1f,
0xc3, 0x94, 0x05, 0xe4, 0x94, 0x00, 0x50, 0x06, 0x75, 0x13, 0x04, 0x75,
0x12, 0x06, 0xe5, 0x13, 0x54, 0x02, 0xc3, 0x13, 0x25, 0xe0, 0x25, 0xe0,
0x54, 0x04, 0xff, 0xe5, 0x13, 0x54, 0x04, 0x13, 0x13, 0x54, 0x3f, 0x33,
0x33, 0x33, 0x54, 0x08, 0x4f, 0xff, 0xe5, 0x13, 0x54, 0x01, 0x25, 0xe0,
0x54, 0x02, 0x4f, 0xf5, 0xa4, 0x75, 0xa6, 0xf1, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0x91, 0xe5, 0x12, 0x54, 0x02, 0xc3, 0x13, 0xc4, 0x54, 0x10, 0xff,
0xe5, 0x12, 0x54, 0x04, 0x13, 0x13, 0x54, 0x3f, 0xc4, 0x33, 0x54, 0x20,
0x4f, 0xff, 0xe5, 0x12, 0x54, 0x01, 0x33, 0x33, 0x33, 0x54, 0x08, 0x4f,
0xf5, 0xa4, 0x75, 0xa6, 0xc7, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x92, 0xe5,
0x13, 0x54, 0x02, 0xc3, 0x13, 0xc4, 0x54, 0x10, 0xff, 0xe5, 0x13, 0x54,
0x04, 0x13, 0x13, 0x54, 0x3f, 0xc4, 0x33, 0x54, 0x20, 0x4f, 0xff, 0xe5,
0x13, 0x54, 0x01, 0xfe, 0x33, 0x33, 0x33, 0x54, 0x08, 0x4f, 0xf5, 0xa4,
0x75, 0xa6, 0xc7, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x93, 0x90, 0x04, 0x49,
0xe0, 0xf5, 0x12, 0xe5, 0x12, 0x64, 0x01, 0x70, 0x05, 0x75, 0xa4, 0x01,
0x80, 0x03, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0xa8, 0xe5, 0x12, 0x64, 0x04, 0x70, 0x05, 0x75, 0xa4, 0x01, 0x80,
0x03, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0xa0, 0x7d, 0x96, 0xe4, 0xff, 0x12, 0x78, 0xdf, 0xef, 0x54, 0x03, 0xff,
0xc3, 0x13, 0x90, 0x04, 0x89, 0xf0, 0x60, 0x05, 0x75, 0xa5, 0x1b, 0x80,
0x03, 0x75, 0xa5, 0x11, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xe0, 0x75, 0x9a,
0xc0, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x01, 0x90, 0x04, 0x49, 0xe0, 0x24, 0xfe, 0xb4, 0x08, 0x00, 0x50, 0x30,
0x90, 0x24, 0x6e, 0x75, 0xf0, 0x03, 0xa4, 0xc5, 0x83, 0x25, 0xf0, 0xc5,
0x83, 0x73, 0x02, 0x24, 0x86, 0x02, 0x24, 0x86, 0x02, 0x24, 0x86, 0x02,
0x24, 0x8b, 0x02, 0x24, 0x8b, 0x02, 0x24, 0x86, 0x02, 0x24, 0x86, 0x02,
0x24, 0x8b, 0x75, 0xa5, 0x01, 0x80, 0x08, 0x75, 0xa5, 0x02, 0x80, 0x03,
0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfc, 0x75, 0x9a, 0x03,
0x22, 0xe7, 0x09, 0xf6, 0x08, 0xdf, 0xfa, 0x80, 0x46, 0xe7, 0x09, 0xf2,
0x08, 0xdf, 0xfa, 0x80, 0x3e, 0x88, 0x82, 0x8c, 0x83, 0xe7, 0x09, 0xf0,
0xa3, 0xdf, 0xfa, 0x80, 0x32, 0xe3, 0x09, 0xf6, 0x08, 0xdf, 0xfa, 0x80,
0x78, 0xe3, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x70, 0x88, 0x82, 0x8c,
0x83, 0xe3, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x64, 0x89, 0x82, 0x8a,
0x83, 0xe0, 0xa3, 0xf6, 0x08, 0xdf, 0xfa, 0x80, 0x58, 0x89, 0x82, 0x8a,
0x83, 0xe0, 0xa3, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x4c, 0x80, 0xd2, 0x80,
0xfa, 0x80, 0xc6, 0x80, 0xd4, 0x80, 0x69, 0x80, 0xf2, 0x80, 0x33, 0x80,
0x10, 0x80, 0xa6, 0x80, 0xea, 0x80, 0x9a, 0x80, 0xa8, 0x80, 0xda, 0x80,
0xe2, 0x80, 0xca, 0x80, 0x33, 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe4,
0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xf0, 0xa3,
0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xe9, 0xde, 0xe7,
0x80, 0x0d, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf6, 0x08, 0xdf,
0xf9, 0xec, 0xfa, 0xa9, 0xf0, 0xed, 0xfb, 0x22, 0x89, 0x82, 0x8a, 0x83,
0xec, 0xfa, 0xe0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc,
0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xea,
0xde, 0xe8, 0x80, 0xdb, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf2,
0x08, 0xdf, 0xf9, 0x80, 0xcc, 0x88, 0xf0, 0xef, 0x60, 0x01, 0x0e, 0x4e,
0x60, 0xc3, 0x88, 0xf0, 0xed, 0x24, 0x02, 0xb4, 0x04, 0x00, 0x50, 0xb9,
0xf5, 0x82, 0xeb, 0x24, 0x02, 0xb4, 0x04, 0x00, 0x50, 0xaf, 0x23, 0x23,
0x45, 0x82, 0x23, 0x90, 0x24, 0xed, 0x73, 0xc2, 0xd5, 0x30, 0xf7, 0x07,
0xb2, 0xd5, 0x63, 0xf0, 0xff, 0x05, 0xf0, 0x30, 0xe7, 0x0c, 0xb2, 0xd5,
0xf4, 0x04, 0x84, 0x63, 0xf0, 0xff, 0x05, 0xf0, 0x80, 0x01, 0x84, 0x30,
0xd5, 0x02, 0xf4, 0x04, 0x22, 0xbb, 0x01, 0x06, 0x89, 0x82, 0x8a, 0x83,
0xe0, 0x22, 0x50, 0x02, 0xe7, 0x22, 0xbb, 0xfe, 0x02, 0xe3, 0x22, 0x89,
0x82, 0x8a, 0x83, 0xe4, 0x93, 0x22, 0xbb, 0x01, 0x09, 0x89, 0x82, 0x8a,
0x83, 0xf8, 0xe0, 0x28, 0xf0, 0x22, 0x50, 0x03, 0x27, 0xf7, 0x22, 0xbb,
0xfe, 0x05, 0xf8, 0xe3, 0x28, 0xf3, 0x22, 0x8a, 0x83, 0x89, 0x82, 0xf8,
0xe4, 0x93, 0x28, 0x22, 0xbb, 0x01, 0x06, 0x89, 0x82, 0x8a, 0x83, 0xf0,
0x22, 0x50, 0x02, 0xf7, 0x22, 0xbb, 0xfe, 0x01, 0xf3, 0x22, 0xef, 0x8d,
0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0,
0xa4, 0x2e, 0xfe, 0x22, 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0,
0xe9, 0x9d, 0x42, 0xf0, 0xec, 0x64, 0x80, 0xc8, 0x64, 0x80, 0x98, 0x45,
0xf0, 0x22, 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d,
0x42, 0xf0, 0xe8, 0x9c, 0x45, 0xf0, 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3,
0x13, 0xfc, 0xed, 0x13, 0xfd, 0xee, 0x13, 0xfe, 0xef, 0x13, 0xff, 0xd8,
0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, 0xee, 0x33, 0xfe,
0xed, 0x33, 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xbb, 0x01, 0x07,
0x89, 0x82, 0x8a, 0x83, 0x02, 0x26, 0xf9, 0x50, 0x05, 0xe9, 0xf8, 0x02,
0x26, 0xed, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x27, 0x05, 0x89, 0x82,
0x8a, 0x83, 0x02, 0x27, 0x11, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83,
0x02, 0x27, 0x2d, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x27, 0x21, 0xbb, 0xfe,
0x05, 0xe9, 0xf8, 0x02, 0x27, 0x39, 0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8,
0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, 0xa3, 0x93,
0xf8, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02,
0x93, 0x68, 0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80, 0xdf, 0xef, 0x4e, 0x60,
0x12, 0xef, 0x60, 0x01, 0x0e, 0xed, 0xbb, 0x01, 0x0b, 0x89, 0x82, 0x8a,
0x83, 0xf0, 0xa3, 0xdf, 0xfc, 0xde, 0xfa, 0x22, 0x89, 0xf0, 0x50, 0x07,
0xf7, 0x09, 0xdf, 0xfc, 0xa9, 0xf0, 0x22, 0xbb, 0xfe, 0xfc, 0xf3, 0x09,
0xdf, 0xfc, 0xa9, 0xf0, 0x22, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x08, 0xe6,
0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xa3, 0xe0,
0xfe, 0xa3, 0xe0, 0xff, 0x22, 0xe2, 0xfc, 0x08, 0xe2, 0xfd, 0x08, 0xe2,
0xfe, 0x08, 0xe2, 0xff, 0x22, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd,
0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xec, 0xf6, 0x08,
0xed, 0xf6, 0x08, 0xee, 0xf6, 0x08, 0xef, 0xf6, 0x22, 0xec, 0xf0, 0xa3,
0xed, 0xf0, 0xa3, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xec, 0xf2, 0x08,
0xed, 0xf2, 0x08, 0xee, 0xf2, 0x08, 0xef, 0xf2, 0x22, 0x8f, 0x12, 0x75,
0x1e, 0x03, 0xe5, 0x12, 0x70, 0x07, 0x75, 0x14, 0x1f, 0xf5, 0x13, 0x80,
0x1a, 0xe5, 0x12, 0xb4, 0x01, 0x02, 0x80, 0x0d, 0xe5, 0x12, 0xb4, 0x03,
0x08, 0x75, 0x14, 0x1f, 0xe4, 0xf5, 0x13, 0x80, 0x06, 0xe4, 0xf5, 0x14,
0x75, 0x13, 0xe1, 0x90, 0x04, 0x1c, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xee,
0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xa8, 0x04,
0xa9, 0x05, 0xaa, 0x06, 0xab, 0x07, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff,
0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0xeb, 0x4f, 0xff, 0xea, 0x4e, 0xfe,
0xe9, 0x4d, 0xfd, 0xe8, 0x4c, 0xfc, 0xef, 0x24, 0xf1, 0xf5, 0x18, 0xee,
0x34, 0xff, 0xf5, 0x17, 0xed, 0x34, 0xff, 0xf5, 0x16, 0xec, 0x34, 0xff,
0xf5, 0x15, 0x7f, 0x38, 0x12, 0x78, 0xb8, 0x90, 0x04, 0x1c, 0xee, 0xf0,
0xa3, 0xef, 0xf0, 0x7f, 0x39, 0x12, 0x78, 0xb8, 0xee, 0x54, 0x03, 0x90,
0x04, 0x1e, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x04, 0x1c, 0xe0, 0xfe, 0xa3,
0xe0, 0xff, 0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26,
0x4e, 0xa8, 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xab, 0x07, 0xa3, 0xe0, 0xfe,
0xa3, 0xe0, 0xff, 0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0xeb, 0x4f, 0xff,
0xea, 0x4e, 0xfe, 0xe9, 0x4d, 0xfd, 0xe8, 0x4c, 0xfc, 0xef, 0x24, 0xf1,
0xf5, 0x1c, 0xee, 0x34, 0xff, 0xf5, 0x1b, 0xed, 0x34, 0xff, 0xf5, 0x1a,
0xec, 0x34, 0xff, 0xf5, 0x19, 0x90, 0x04, 0x4f, 0xe0, 0xff, 0xd3, 0x64,
0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x07, 0x90, 0x04, 0x4f, 0xe0, 0xf4,
0x04, 0xff, 0xd3, 0xef, 0x64, 0x80, 0x94, 0x81, 0x40, 0x08, 0x90, 0x04,
0x4f, 0xe0, 0xa2, 0xe7, 0x13, 0xf0, 0x90, 0x04, 0x53, 0xe0, 0x04, 0xf0,
0x90, 0x04, 0x53, 0xe0, 0xd3, 0x94, 0x05, 0x50, 0x38, 0x85, 0x1c, 0x23,
0x85, 0x1b, 0x22, 0x85, 0x1a, 0x21, 0x85, 0x19, 0x20, 0x90, 0x04, 0x51,
0xe0, 0xf5, 0x24, 0x85, 0x18, 0x28, 0x85, 0x17, 0x27, 0x85, 0x16, 0x26,
0x85, 0x15, 0x25, 0x85, 0x13, 0x29, 0x85, 0x14, 0x2a, 0x90, 0x04, 0x4f,
0xe0, 0xf5, 0x2b, 0xe4, 0xf5, 0x2c, 0xa3, 0xe0, 0xff, 0x12, 0x5c, 0x83,
0x8f, 0x1d, 0xe4, 0x80, 0x42, 0x90, 0x04, 0x53, 0xe0, 0xd3, 0x94, 0x07,
0x50, 0x3f, 0x85, 0x1c, 0x23, 0x85, 0x1b, 0x22, 0x85, 0x1a, 0x21, 0x85,
0x19, 0x20, 0x90, 0x04, 0x51, 0xe0, 0xf5, 0x24, 0x85, 0x18, 0x28, 0x85,
0x17, 0x27, 0x85, 0x16, 0x26, 0x85, 0x15, 0x25, 0x85, 0x13, 0x29, 0x85,
0x14, 0x2a, 0x90, 0x04, 0x4f, 0xe0, 0xf5, 0x2b, 0x75, 0x2c, 0x01, 0xa3,
0xe0, 0xff, 0x12, 0x5c, 0x83, 0x8f, 0x1d, 0x90, 0x04, 0x62, 0xe0, 0x90,
0x04, 0x4d, 0xf0, 0x80, 0x0c, 0x90, 0x04, 0x50, 0xe0, 0xf5, 0x1d, 0x90,
0x04, 0x4d, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x50, 0xe0, 0xa3, 0xf0, 0x90,
0x04, 0x50, 0xe5, 0x1d, 0xf0, 0xe5, 0x12, 0x60, 0x03, 0xb4, 0x01, 0x0a,
0x90, 0x04, 0x50, 0xe0, 0xff, 0x12, 0x73, 0x80, 0x80, 0x08, 0x90, 0x04,
0x50, 0xe0, 0xff, 0x12, 0x5f, 0x3c, 0x90, 0x04, 0x4d, 0xe0, 0x64, 0x01,
0x60, 0x03, 0x02, 0x29, 0x99, 0xe5, 0x12, 0x70, 0x21, 0x90, 0x04, 0x50,
0xe0, 0xff, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x07, 0x90,
0x04, 0x50, 0xe0, 0xf4, 0x04, 0xff, 0xef, 0x33, 0x33, 0x33, 0x54, 0xf8,
0x90, 0x04, 0x0f, 0xf0, 0x80, 0x6b, 0xe5, 0x12, 0xb4, 0x01, 0x21, 0x90,
0x04, 0x50, 0xe0, 0xff, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80,
0x07, 0x90, 0x04, 0x50, 0xe0, 0xf4, 0x04, 0xff, 0xef, 0x33, 0x33, 0x33,
0x54, 0xf8, 0x90, 0x04, 0x10, 0xf0, 0x80, 0x45, 0xe5, 0x12, 0xb4, 0x02,
0x21, 0x90, 0x04, 0x50, 0xe0, 0xff, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40,
0x02, 0x80, 0x07, 0x90, 0x04, 0x50, 0xe0, 0xf4, 0x04, 0xff, 0xef, 0x33,
0x33, 0x33, 0x54, 0xf8, 0x90, 0x04, 0x0d, 0xf0, 0x80, 0x1f, 0x90, 0x04,
0x50, 0xe0, 0xff, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x07,
0x90, 0x04, 0x50, 0xe0, 0xf4, 0x04, 0xff, 0xef, 0x33, 0x33, 0x33, 0x54,
0xf8, 0x90, 0x04, 0x0e, 0xf0, 0x7f, 0x00, 0x22, 0x75, 0x12, 0x00, 0x75,
0x13, 0x20, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xdd, 0x70, 0x03, 0x02, 0x2a,
0x40, 0x14, 0x70, 0x03, 0x02, 0x2a, 0x66, 0x80, 0x00, 0x90, 0x04, 0x49,
0xe0, 0x70, 0x13, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02,
0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x03, 0x7f, 0x00,
0x22, 0xe4, 0x90, 0x04, 0x20, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x7b, 0xe0,
0x64, 0x01, 0x60, 0x05, 0xe4, 0x90, 0x04, 0x4b, 0xf0, 0x90, 0x04, 0x7c,
0xe0, 0x60, 0x45, 0x90, 0x04, 0x45, 0xe0, 0xff, 0x33, 0x95, 0xe0, 0xfe,
0xc3, 0xef, 0x95, 0x13, 0xff, 0xee, 0x95, 0x12, 0xfe, 0xd3, 0xef, 0x94,
0x00, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40, 0x03, 0xe0, 0x14, 0xf0, 0x90,
0x04, 0x45, 0xe0, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xc3, 0xef, 0x95, 0x13,
0xee, 0x95, 0x12, 0xc3, 0x64, 0x80, 0x94, 0x80, 0x50, 0x03, 0xe0, 0x04,
0xf0, 0x90, 0x04, 0x20, 0xe4, 0xf0, 0xa3, 0x04, 0xf0, 0x02, 0x2b, 0xa1,
0x90, 0x04, 0x03, 0xe0, 0x24, 0xf8, 0xff, 0x12, 0x5f, 0x3c, 0x90, 0x04,
0x40, 0x74, 0x23, 0xf0, 0x12, 0x60, 0x8a, 0xbf, 0x02, 0x03, 0x7f, 0x02,
0x22, 0x90, 0x04, 0x53, 0xe0, 0xff, 0x90, 0x04, 0x24, 0xe4, 0xf0, 0xa3,
0xef, 0xf0, 0x90, 0x04, 0x03, 0xe0, 0x24, 0x08, 0xff, 0x12, 0x5f, 0x3c,
0x90, 0x04, 0x40, 0x74, 0x24, 0xf0, 0x12, 0x60, 0x8a, 0xbf, 0x02, 0x03,
0x7f, 0x02, 0x22, 0x90, 0x04, 0x53, 0xe0, 0xff, 0x90, 0x04, 0x24, 0xe0,
0xfc, 0xa3, 0xe0, 0xfd, 0xc3, 0xef, 0x9d, 0xfe, 0xe4, 0x9c, 0x90, 0x04,
0x24, 0xf0, 0xa3, 0xce, 0xf0, 0x90, 0x04, 0x24, 0xe0, 0xfe, 0xa3, 0xe0,
0x4e, 0x60, 0x3d, 0x90, 0x04, 0x4b, 0xe0, 0xd3, 0x94, 0x00, 0x50, 0x03,
0x02, 0x2b, 0x5b, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0x7e, 0x00,
0x7f, 0x01, 0x80, 0x04, 0x7e, 0xff, 0x7f, 0xff, 0x90, 0x04, 0x52, 0xe0,
0xc3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0x7c, 0x00, 0x7d, 0x01, 0x80,
0x04, 0x7c, 0xff, 0x7d, 0xff, 0xef, 0x6d, 0x70, 0x02, 0xee, 0x6c, 0x70,
0x03, 0x02, 0x2b, 0x5b, 0x90, 0x04, 0x20, 0xe4, 0xf0, 0xa3, 0x04, 0xf0,
0x90, 0x04, 0x24, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xd3, 0x94, 0x00, 0xee,
0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x0f, 0x90, 0x04, 0x24, 0xe0,
0xfe, 0xa3, 0xe0, 0xff, 0xc3, 0xe4, 0x9f, 0xff, 0xe4, 0x9e, 0xfe, 0x90,
0x04, 0x52, 0xe0, 0xfd, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80,
0x07, 0x90, 0x04, 0x52, 0xe0, 0xf4, 0x04, 0xfd, 0xed, 0x33, 0x95, 0xe0,
0xfc, 0xd3, 0xef, 0x9d, 0xec, 0x64, 0x80, 0xf8, 0xee, 0x64, 0x80, 0x98,
0x40, 0x76, 0x90, 0x04, 0x7a, 0xe0, 0x64, 0x01, 0x60, 0x26, 0x90, 0x04,
0x45, 0xe0, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0x90, 0x04, 0x52, 0xe0, 0xc3,
0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0x7c, 0x00, 0x7d, 0x01, 0x80, 0x04,
0x7c, 0xff, 0x7d, 0xff, 0xed, 0x2f, 0xff, 0xec, 0x3e, 0xfe, 0x80, 0x43,
0x90, 0x04, 0x45, 0xe0, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0x80, 0x38, 0x90,
0x04, 0x7a, 0xe0, 0x64, 0x01, 0x60, 0x27, 0xc3, 0x90, 0x04, 0x24, 0xe0,
0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0x7e, 0x00, 0x7f, 0x01, 0x80, 0x04,
0x7e, 0xff, 0x7f, 0xff, 0x90, 0x04, 0x45, 0xe0, 0xfd, 0x33, 0x95, 0xe0,
0xfc, 0xc3, 0xed, 0x9f, 0xff, 0xec, 0x9e, 0xfe, 0x80, 0x09, 0x90, 0x04,
0x45, 0xe0, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0x90, 0x04, 0x45, 0xef, 0xf0,
0x90, 0x04, 0x24, 0xa3, 0xe0, 0x90, 0x04, 0x52, 0xf0, 0x90, 0x04, 0x45,
0xe0, 0xff, 0x12, 0x63, 0x09, 0x90, 0x04, 0x4b, 0xe0, 0x04, 0xf0, 0x90,
0x04, 0x20, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x01, 0x60, 0x11, 0x90,
0x04, 0x4b, 0xe0, 0xc3, 0x94, 0x10, 0x50, 0x08, 0x90, 0x04, 0x7b, 0x74,
0x01, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0x04, 0x7b, 0xf0, 0xe4, 0x90, 0x04,
0x40, 0xf0, 0xff, 0x12, 0x5f, 0x3c, 0x7f, 0x00, 0x22, 0xe4, 0xf5, 0xa5,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0xbf, 0x75, 0x9a, 0xb4, 0xe4, 0xf5, 0xa5,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfc, 0x75, 0x9a, 0xb4, 0xe4, 0xf5, 0xa5,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0xcf, 0x75, 0x9a, 0xb4, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xbf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0xb1, 0xef, 0xb4, 0x09,
0x00, 0x40, 0x03, 0x02, 0x2e, 0x09, 0x90, 0x2c, 0x1d, 0xf8, 0x28, 0x28,
0x73, 0x02, 0x2c, 0x40, 0x02, 0x2c, 0x5d, 0x02, 0x2c, 0xaa, 0x02, 0x2c,
0xf7, 0x02, 0x2d, 0x14, 0x02, 0x2d, 0x31, 0x02, 0x2d, 0x7e, 0x02, 0x2d,
0x9a, 0x02, 0x2d, 0xb6, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x27, 0x80, 0x0f,
0x75, 0xa4, 0x01, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1,
0x75, 0x9c, 0x27, 0x90, 0x00, 0x50, 0xe0, 0xfe, 0xa3, 0xe0, 0x54, 0xc1,
0x44, 0x2e, 0x02, 0x2e, 0x00, 0x75, 0xa4, 0x02, 0x75, 0xa6, 0xf0, 0x75,
0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x27, 0x75, 0xa5, 0x40, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0xbf, 0x75, 0x9a, 0xb4, 0x75, 0xa5, 0x03, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0xfc, 0x75, 0x9a, 0xb4, 0x75, 0xa5, 0x20, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0xcf, 0x75, 0x9a, 0xb4, 0x75, 0xa4, 0x40, 0x75,
0xa6, 0xbf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0xb1, 0x90, 0x00, 0x50, 0xe0,
0xfe, 0xa3, 0xe0, 0x54, 0xc1, 0x44, 0x06, 0x02, 0x2e, 0x00, 0x75, 0xa4,
0x03, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c,
0x27, 0x75, 0xa5, 0x40, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xbf, 0x75, 0x9a,
0xb4, 0x75, 0xa5, 0x03, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfc, 0x75, 0x9a,
0xb4, 0x75, 0xa5, 0x20, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xcf, 0x75, 0x9a,
0xb4, 0x75, 0xa4, 0x40, 0x75, 0xa6, 0xbf, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0xb1, 0x90, 0x00, 0x50, 0xe0, 0xfe, 0xa3, 0xe0, 0x54, 0xc1, 0x44, 0x08,
0x02, 0x2e, 0x00, 0x75, 0xa4, 0x06, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff,
0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x27, 0x90, 0x00, 0x50, 0xe0, 0xfe, 0xa3,
0xe0, 0x54, 0xc1, 0x44, 0x14, 0x02, 0x2e, 0x00, 0x75, 0xa4, 0x08, 0x75,
0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x27, 0x90,
0x00, 0x50, 0xe0, 0xfe, 0xa3, 0xe0, 0x54, 0xc1, 0x44, 0x1e, 0x02, 0x2e,
0x00, 0x75, 0xa4, 0x09, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9e,
0xd1, 0x75, 0x9c, 0x27, 0x75, 0xa5, 0x40, 0x75, 0xa6, 0xff, 0x75, 0xa7,
0xbf, 0x75, 0x9a, 0xb4, 0x75, 0xa5, 0x01, 0x75, 0xa6, 0xff, 0x75, 0xa7,
0xfc, 0x75, 0x9a, 0xb4, 0x75, 0xa5, 0x10, 0x75, 0xa6, 0xff, 0x75, 0xa7,
0xcf, 0x75, 0x9a, 0xb4, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xbf, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0xb1, 0x90, 0x00, 0x50, 0xe0, 0xfe, 0xa3, 0xe0, 0x54,
0xc1, 0x44, 0x24, 0x02, 0x2e, 0x00, 0x75, 0xa4, 0x0a, 0x75, 0xa6, 0xf0,
0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c, 0x27, 0x90, 0x00, 0x50,
0xe0, 0xfe, 0xa3, 0xe0, 0x54, 0xc1, 0x44, 0x26, 0x80, 0x66, 0x75, 0xa4,
0x0c, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c,
0x27, 0x90, 0x00, 0x50, 0xe0, 0xfe, 0xa3, 0xe0, 0x54, 0xc1, 0x44, 0x2a,
0x80, 0x4a, 0x75, 0xa4, 0x0d, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75,
0x9e, 0xd1, 0x75, 0x9c, 0x27, 0x75, 0xa5, 0x40, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xbf, 0x75, 0x9a, 0xb4, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xfc, 0x75, 0x9a, 0xb4, 0x75, 0xa5, 0x20, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xcf, 0x75, 0x9a, 0xb4, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xbf, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0xb1, 0x90, 0x00, 0x50, 0xe0, 0xfe, 0xa3, 0xe0,
0x54, 0xc1, 0x44, 0x38, 0xff, 0x90, 0x00, 0x50, 0xee, 0xf0, 0xa3, 0xef,
0xf0, 0x22, 0xef, 0x24, 0xfe, 0x70, 0x03, 0x02, 0x2e, 0xb1, 0x14, 0x70,
0x03, 0x02, 0x2f, 0xd4, 0x14, 0x70, 0x03, 0x02, 0x2f, 0xec, 0x14, 0x70,
0x03, 0x02, 0x30, 0x04, 0x24, 0x04, 0x60, 0x03, 0x02, 0x30, 0x27, 0xd3,
0xed, 0x64, 0x80, 0x94, 0xc6, 0x40, 0x02, 0x7d, 0x46, 0xd3, 0xed, 0x64,
0x80, 0x94, 0xbf, 0x40, 0x06, 0xed, 0x24, 0xc1, 0xff, 0x80, 0x02, 0x7f,
0x00, 0xac, 0x07, 0xec, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0xf5, 0xa4,
0xee, 0x54, 0x01, 0x44, 0x04, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a,
0x2b, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a,
0x2b, 0xec, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0xf5, 0xa4, 0xee, 0x54,
0x01, 0x44, 0x06, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75,
0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0xec,
0xff, 0x33, 0x95, 0xe0, 0xfe, 0xed, 0xfb, 0x33, 0x95, 0xe0, 0xfa, 0xc3,
0xeb, 0x9f, 0xff, 0xea, 0x9e, 0xfe, 0xef, 0xf5, 0xa4, 0xee, 0x54, 0x01,
0x44, 0x02, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x02, 0x30,
0x1a, 0xd3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xaf, 0x05, 0x80,
0x04, 0xed, 0xf4, 0x04, 0xff, 0xd3, 0xef, 0x64, 0x80, 0x94, 0x9f, 0x40,
0x16, 0xd3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xaf, 0x05, 0x80,
0x04, 0xed, 0xf4, 0x04, 0xff, 0xef, 0x24, 0xe1, 0xff, 0x80, 0x02, 0x7f,
0x00, 0xac, 0x07, 0xec, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0xf5, 0xa4,
0xee, 0x54, 0x01, 0x44, 0x0a, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a,
0x2b, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a,
0x2b, 0xec, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0xf5, 0xa4, 0xee, 0x54,
0x01, 0x44, 0x0c, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75,
0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0xd3,
0xed, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xaf, 0x05, 0x80, 0x04, 0xed,
0xf4, 0x04, 0xff, 0xef, 0x33, 0x95, 0xe0, 0xec, 0xfb, 0x33, 0x95, 0xe0,
0xfa, 0xc3, 0xef, 0x9b, 0xff, 0xef, 0xf5, 0xa4, 0xd3, 0xed, 0x64, 0x80,
0x94, 0x80, 0x40, 0x04, 0xaf, 0x05, 0x80, 0x04, 0xed, 0xf4, 0x04, 0xff,
0xef, 0x33, 0x95, 0xe0, 0xfe, 0xc3, 0xef, 0x9b, 0xee, 0x9a, 0x54, 0x01,
0x44, 0x08, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75, 0xa5,
0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0xc3, 0xed,
0x64, 0x80, 0x94, 0x80, 0x50, 0x04, 0x7f, 0x01, 0x80, 0x02, 0x7f, 0x00,
0xef, 0xf5, 0xa4, 0xc3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x7e, 0x00, 0xee,
0x54, 0x01, 0x44, 0x14, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b,
0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b,
0xc3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x50, 0x04, 0x7f, 0x01, 0x80, 0x02,
0x7f, 0x00, 0xef, 0xf5, 0xa4, 0xc3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x7e,
0x00, 0xee, 0x54, 0x01, 0x44, 0x16, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75,
0x9a, 0x2b, 0x80, 0x46, 0xed, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0xf5,
0xa4, 0xee, 0x54, 0x01, 0x44, 0x0e, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75,
0x9a, 0x2b, 0x80, 0x2e, 0xed, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0xf5,
0xa4, 0xee, 0x54, 0x01, 0x44, 0x10, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75,
0x9a, 0x2b, 0x80, 0x16, 0xed, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0xf5,
0xa4, 0xee, 0x54, 0x01, 0x44, 0x12, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75,
0x9a, 0x2b, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75,
0x9a, 0x2b, 0x22, 0x22, 0x90, 0x04, 0x6e, 0xe0, 0x70, 0x1e, 0x90, 0x04,
0x86, 0xe0, 0x60, 0x18, 0x7d, 0x99, 0xe4, 0xff, 0x12, 0x78, 0x87, 0xee,
0x30, 0xe7, 0x0d, 0x90, 0x04, 0x6e, 0x74, 0x01, 0xf0, 0x7d, 0x02, 0x7f,
0x10, 0x12, 0x34, 0x1e, 0x90, 0x04, 0x41, 0xe0, 0x24, 0xdb, 0xb4, 0x07,
0x00, 0x50, 0x23, 0x90, 0x30, 0x65, 0x75, 0xf0, 0x03, 0xa4, 0xc5, 0x83,
0x25, 0xf0, 0xc5, 0x83, 0x73, 0x02, 0x30, 0x9d, 0x02, 0x31, 0x68, 0x02,
0x31, 0xb8, 0x02, 0x31, 0x82, 0x02, 0x31, 0xcf, 0x02, 0x31, 0xf5, 0x02,
0x32, 0x18, 0x75, 0xa4, 0x02, 0x75, 0xa6, 0xfd, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0x51, 0x7d, 0x02, 0x7f, 0x08, 0x12, 0x34, 0x1e, 0x12, 0x67, 0x47,
0x90, 0x04, 0x20, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0x90, 0x04, 0x4e,
0xf0, 0x7f, 0x65, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0xf5, 0x12, 0x70,
0x6f, 0x12, 0x67, 0x47, 0xc3, 0x90, 0x04, 0x21, 0xe0, 0x9f, 0xff, 0x90,
0x04, 0x20, 0xe0, 0x9e, 0xfe, 0xc3, 0xef, 0x94, 0x64, 0xee, 0x94, 0x00,
0x40, 0x4f, 0x90, 0x04, 0x4e, 0xe0, 0x70, 0x07, 0x90, 0x04, 0x00, 0xe0,
0x20, 0xe0, 0x15, 0x7d, 0x02, 0x7f, 0x0f, 0x12, 0x34, 0x1e, 0x75, 0xa4,
0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x19, 0x80, 0x2d,
0x7f, 0xd3, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0x64, 0x01, 0xf5, 0xa4,
0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0xd3, 0x12, 0x67, 0x47,
0x90, 0x04, 0x20, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x04, 0x4e, 0x74,
0x01, 0xf0, 0x7d, 0x02, 0x7f, 0x1d, 0x12, 0x34, 0x1e, 0x90, 0x04, 0x41,
0x74, 0x25, 0xf0, 0x22, 0x90, 0x04, 0x86, 0x74, 0x01, 0xf0, 0x7d, 0x99,
0xe4, 0xff, 0x12, 0x78, 0x87, 0x8e, 0x13, 0x8f, 0x14, 0xef, 0x7d, 0x03,
0x12, 0x40, 0x1f, 0x12, 0x34, 0x1a, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75,
0x9a, 0x60, 0xe4, 0xf5, 0xa4, 0x75, 0xa5, 0x80, 0x75, 0x9a, 0x60, 0xe4,
0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0x9a, 0x60, 0x90, 0x04, 0x41, 0x74, 0x26,
0xf0, 0xe4, 0xf5, 0x13, 0xf5, 0x14, 0xaf, 0x14, 0xae, 0x13, 0x12, 0x5a,
0x3b, 0xef, 0x64, 0x01, 0x60, 0x39, 0x90, 0x04, 0x41, 0x74, 0x26, 0xf0,
0x7f, 0x65, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x01, 0xf5, 0x12, 0x70, 0x03,
0x02, 0x32, 0x24, 0x90, 0x04, 0x40, 0x74, 0x14, 0xf0, 0xa3, 0x74, 0x28,
0xf0, 0x22, 0x7f, 0x50, 0x12, 0x78, 0xb8, 0x8e, 0x13, 0x8f, 0x14, 0xef,
0x7d, 0x03, 0x12, 0x40, 0x1f, 0x12, 0x34, 0x1a, 0x90, 0x04, 0x69, 0xe0,
0xb4, 0x01, 0xbb, 0x90, 0x04, 0x41, 0x74, 0x27, 0xf0, 0xe4, 0xf5, 0x13,
0xf5, 0x14, 0xaf, 0x14, 0xae, 0x13, 0x12, 0x66, 0x55, 0xef, 0x64, 0x01,
0x60, 0x36, 0x90, 0x04, 0x41, 0x74, 0x27, 0xf0, 0x7f, 0x65, 0x12, 0x78,
0xeb, 0xef, 0x54, 0x01, 0xf5, 0x12, 0x60, 0x60, 0x90, 0x04, 0x40, 0x74,
0x14, 0xf0, 0xa3, 0x74, 0x29, 0xf0, 0x22, 0x7f, 0x50, 0x12, 0x78, 0xb8,
0x8e, 0x13, 0x8f, 0x14, 0xef, 0x7d, 0x03, 0x12, 0x40, 0x1f, 0x12, 0x34,
0x1a, 0x90, 0x04, 0x6a, 0xe0, 0xb4, 0x01, 0xbe, 0x90, 0x04, 0x3d, 0xe0,
0x44, 0x04, 0xf0, 0x90, 0x04, 0x41, 0x74, 0x2a, 0xf0, 0x90, 0x04, 0x3c,
0xe0, 0xc3, 0x13, 0x20, 0xe0, 0x01, 0x22, 0x75, 0xa4, 0x01, 0x75, 0xa6,
0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x61, 0x7d, 0x02, 0x7f, 0x0c, 0x12,
0x34, 0x1e, 0x90, 0x04, 0x41, 0x74, 0x2b, 0xf0, 0x90, 0x04, 0x6e, 0xe0,
0x60, 0x06, 0x90, 0x04, 0x41, 0x74, 0x2c, 0xf0, 0x22, 0xe4, 0xf5, 0xa4,
0xf5, 0xa5, 0x75, 0xa6, 0x7f, 0x75, 0xa7, 0xf8, 0x75, 0x9a, 0x01, 0x75,
0xa4, 0x90, 0x75, 0xa5, 0x06, 0x75, 0xa6, 0x01, 0x75, 0x9a, 0x02, 0xe4,
0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x03, 0xe4,
0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0xa6, 0x80, 0x75, 0xa7, 0x81, 0x75, 0x9a,
0x04, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0xa6, 0x1f, 0x75, 0xa7, 0xbf,
0x75, 0x9a, 0x10, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xcf, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x11, 0x75, 0xa5, 0x34, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x83,
0x75, 0x9a, 0x14, 0x75, 0xa4, 0x0d, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x15, 0x75, 0xa4, 0x01, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xf0,
0x75, 0xa7, 0xfc, 0x75, 0x9a, 0x18, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0x3f, 0x75, 0x9a, 0x20, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75,
0xa6, 0xfd, 0x75, 0xa7, 0x13, 0x75, 0x9a, 0x21, 0xe4, 0xf5, 0xa4, 0xf5,
0xa5, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x22, 0xe4, 0xf5,
0xa4, 0xf5, 0xa5, 0x75, 0xa6, 0xfd, 0x75, 0xa7, 0x13, 0x75, 0x9a, 0x23,
0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xc0, 0x75,
0x9a, 0x24, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x13, 0x75,
0x9a, 0x25, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0xa6, 0xc0, 0x75, 0xa7,
0xc0, 0x75, 0x9a, 0x26, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7,
0x13, 0x75, 0x9a, 0x27, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0xa6, 0xc0,
0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x28, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0x13, 0x75, 0x9a, 0x29, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75,
0xa6, 0xc0, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2a, 0xe4, 0xf5, 0xa4, 0xf5,
0xa5, 0x75, 0xa7, 0x40, 0x75, 0x9a, 0x2b, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5,
0x75, 0xa6, 0x03, 0x75, 0xa7, 0x01, 0x75, 0x9a, 0x30, 0xe4, 0xf5, 0xa4,
0xf5, 0xa5, 0x75, 0x9a, 0x31, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0x9a,
0x32, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0x9a, 0x33, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xf6, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x40, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x41, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xf8, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x42, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x43, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x44, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x45, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x46, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x47, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x48, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0x80, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x49, 0xe4, 0xf5, 0xa4,
0x75, 0xa6, 0xfd, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x51, 0xe4, 0xf5, 0xa4,
0xf5, 0xa5, 0x75, 0x9a, 0x60, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x61, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0x7f, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x90, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x98, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xfb, 0x75, 0x9a, 0xd1, 0x22, 0x7d, 0x03, 0x7f, 0x09, 0x8f, 0x1a,
0x90, 0x00, 0x5a, 0xe0, 0xf5, 0x1b, 0xa3, 0xe0, 0xf5, 0x1c, 0x75, 0x1d,
0x04, 0xc3, 0xe5, 0x1c, 0x94, 0xf8, 0xe5, 0x1b, 0x94, 0x02, 0x40, 0x03,
0x02, 0x35, 0xf6, 0xe5, 0x1a, 0x94, 0x00, 0x50, 0x03, 0x02, 0x35, 0xf6,
0xe5, 0x1a, 0x94, 0x33, 0x40, 0x03, 0x02, 0x35, 0xf6, 0x90, 0x00, 0x65,
0xe0, 0x64, 0x01, 0x70, 0x03, 0x02, 0x35, 0xf6, 0x90, 0x04, 0x05, 0xe0,
0xc3, 0x9d, 0x50, 0x03, 0x02, 0x35, 0xf6, 0x90, 0x00, 0x5d, 0xe0, 0xb4,
0xff, 0x15, 0xe5, 0x1c, 0x24, 0x08, 0xff, 0xe4, 0x35, 0x1b, 0xfe, 0xd3,
0xef, 0x94, 0xf8, 0xee, 0x94, 0x02, 0x40, 0x03, 0x02, 0x35, 0xf6, 0xe5,
0x33, 0x60, 0x03, 0x02, 0x35, 0x48, 0x12, 0x76, 0xf7, 0x8e, 0x34, 0x8f,
0x35, 0x90, 0x00, 0x60, 0xe0, 0x30, 0xe0, 0x11, 0x54, 0xfe, 0xf0, 0x90,
0x00, 0x67, 0xe0, 0x04, 0xf0, 0x70, 0x06, 0x90, 0x00, 0x66, 0xe0, 0x04,
0xf0, 0xd3, 0x90, 0x00, 0x67, 0xe0, 0x94, 0x00, 0x90, 0x00, 0x66, 0xe0,
0x94, 0x00, 0x50, 0x03, 0x02, 0x35, 0x48, 0x74, 0x02, 0x25, 0x1c, 0xf5,
0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83, 0x74, 0xff, 0xf0, 0x90, 0x00,
0x66, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xec, 0xff, 0x74, 0x01, 0x25, 0x1c,
0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83, 0xef, 0xf0, 0x74, 0x00,
0x25, 0x1c, 0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83, 0xed, 0xf0,
0x74, 0x03, 0x25, 0x1c, 0xf5, 0x1c, 0xe4, 0x35, 0x1b, 0xf5, 0x1b, 0xc3,
0xe5, 0x1c, 0x94, 0xf8, 0xe5, 0x1b, 0x94, 0x02, 0x40, 0x3f, 0xe4, 0xf5,
0x1e, 0xe5, 0x1c, 0x24, 0x08, 0xff, 0xe5, 0x1b, 0x34, 0xfd, 0xfe, 0xc3,
0xe5, 0x1e, 0x9f, 0xe4, 0x9e, 0x50, 0x1e, 0x74, 0xf8, 0x25, 0x1e, 0xf5,
0x82, 0xe4, 0x34, 0x03, 0xf5, 0x83, 0xe0, 0xff, 0x74, 0x00, 0x25, 0x1e,
0xf5, 0x82, 0xe4, 0x34, 0x01, 0xf5, 0x83, 0xef, 0xf0, 0x05, 0x1e, 0x80,
0xd0, 0x74, 0x08, 0x25, 0x1c, 0xf5, 0x1c, 0x74, 0xfd, 0x35, 0x1b, 0xf5,
0x1b, 0xe4, 0x90, 0x00, 0x66, 0xf0, 0xa3, 0xf0, 0xe5, 0x1d, 0x25, 0x33,
0xc4, 0x33, 0x54, 0xe0, 0x45, 0x38, 0xff, 0x74, 0x03, 0x25, 0x1c, 0xf5,
0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83, 0xef, 0xf0, 0xe5, 0x34, 0xff,
0x74, 0x02, 0x25, 0x1c, 0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83,
0xef, 0xf0, 0x74, 0x01, 0x25, 0x1c, 0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b,
0xf5, 0x83, 0xe5, 0x35, 0xf0, 0x74, 0x00, 0x25, 0x1c, 0xf5, 0x82, 0x74,
0x01, 0x35, 0x1b, 0xf5, 0x83, 0xe5, 0x1a, 0xf0, 0x74, 0x04, 0x25, 0x1c,
0xf5, 0x1c, 0xe4, 0x35, 0x1b, 0xf5, 0x1b, 0xc3, 0xe5, 0x1c, 0x94, 0xf8,
0xe5, 0x1b, 0x94, 0x02, 0x40, 0x3f, 0xe4, 0xf5, 0x1e, 0xe5, 0x1c, 0x24,
0x08, 0xff, 0xe5, 0x1b, 0x34, 0xfd, 0xfe, 0xc3, 0xe5, 0x1e, 0x9f, 0xe4,
0x9e, 0x50, 0x1e, 0x74, 0xf8, 0x25, 0x1e, 0xf5, 0x82, 0xe4, 0x34, 0x03,
0xf5, 0x83, 0xe0, 0xff, 0x74, 0x00, 0x25, 0x1e, 0xf5, 0x82, 0xe4, 0x34,
0x01, 0xf5, 0x83, 0xef, 0xf0, 0x05, 0x1e, 0x80, 0xd0, 0x74, 0x08, 0x25,
0x1c, 0xf5, 0x1c, 0x74, 0xfd, 0x35, 0x1b, 0xf5, 0x1b, 0xe4, 0xf5, 0x34,
0xf5, 0x35, 0xf5, 0x33, 0x90, 0x00, 0x5a, 0xe5, 0x1b, 0xf0, 0xa3, 0xe5,
0x1c, 0xf0, 0x22, 0x7f, 0x3b, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x07, 0xff,
0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3b, 0x12, 0x78, 0xe6, 0xef,
0x54, 0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f, 0xfd, 0xd0, 0xe0, 0x2d, 0xff,
0xd0, 0xe0, 0x34, 0x00, 0xc3, 0x13, 0xfe, 0xef, 0x13, 0xff, 0xc0, 0x06,
0xc0, 0x07, 0x7f, 0x3b, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xfd, 0xd0,
0xe0, 0x2d, 0xf5, 0x14, 0xd0, 0xe0, 0x34, 0x00, 0xf5, 0x13, 0x7f, 0x3c,
0x12, 0x78, 0xeb, 0xef, 0x54, 0x1f, 0xff, 0x7e, 0x00, 0xc0, 0x06, 0xc0,
0x07, 0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x3f, 0x13, 0x13, 0x13,
0x54, 0x1f, 0xfd, 0xd0, 0xe0, 0x2d, 0xf5, 0x1e, 0xd0, 0xe0, 0x34, 0x00,
0xf5, 0x1d, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x7f, 0xc4, 0x13,
0x13, 0x54, 0x03, 0x64, 0x01, 0x70, 0x0a, 0xc3, 0x95, 0x1e, 0xff, 0xe4,
0x95, 0x1d, 0xfe, 0x80, 0x04, 0xae, 0x1d, 0xaf, 0x1e, 0x8e, 0x17, 0x8f,
0x18, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x1f, 0xff, 0x7e, 0x00,
0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x07,
0xfd, 0xd0, 0xe0, 0x2d, 0xf5, 0x20, 0xd0, 0xe0, 0x34, 0x00, 0xf5, 0x1f,
0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xc4, 0x13, 0x54, 0x07,
0x64, 0x01, 0x70, 0x0a, 0xc3, 0x95, 0x20, 0xff, 0xe4, 0x95, 0x1f, 0xfe,
0x80, 0x04, 0xae, 0x1f, 0xaf, 0x20, 0xe5, 0x18, 0x2f, 0xff, 0xe5, 0x17,
0x3e, 0xa2, 0xe7, 0x13, 0xf5, 0x15, 0xef, 0x13, 0xf5, 0x16, 0x7f, 0x3d,
0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c,
0x00, 0x12, 0x77, 0xe0, 0xef, 0x33, 0x95, 0xe0, 0xf5, 0x19, 0x8f, 0x1a,
0x7f, 0x3d, 0x12, 0x78, 0xb8, 0xee, 0x54, 0x07, 0xfe, 0x7d, 0x00, 0x7c,
0x04, 0x12, 0x77, 0xe0, 0xef, 0x78, 0x06, 0xce, 0xa2, 0xe7, 0x13, 0xce,
0x13, 0xd8, 0xf8, 0xff, 0x33, 0x95, 0xe0, 0xf5, 0x1b, 0x8f, 0x1c, 0x7f,
0x3d, 0x12, 0x78, 0xb8, 0xef, 0x78, 0x0b, 0xce, 0xa2, 0xe7, 0x13, 0xce,
0x13, 0xd8, 0xf8, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xd3, 0xe5, 0x16, 0x94,
0x00, 0xe5, 0x15, 0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0xac, 0x15, 0xad,
0x16, 0x80, 0x09, 0xc3, 0xe4, 0x95, 0x16, 0xfd, 0xe4, 0x95, 0x15, 0xfc,
0xd3, 0xe5, 0x14, 0x94, 0x00, 0xe5, 0x13, 0x64, 0x80, 0x94, 0x80, 0x40,
0x06, 0xaa, 0x13, 0xab, 0x14, 0x80, 0x09, 0xc3, 0xe4, 0x95, 0x14, 0xfb,
0xe4, 0x95, 0x13, 0xfa, 0xeb, 0x2d, 0xfd, 0xea, 0x3c, 0xfc, 0xd3, 0xe5,
0x1a, 0x94, 0x00, 0xe5, 0x19, 0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0xaa,
0x19, 0xab, 0x1a, 0x80, 0x09, 0xc3, 0xe4, 0x95, 0x1a, 0xfb, 0xe4, 0x95,
0x19, 0xfa, 0xed, 0x2b, 0xfd, 0xec, 0x3a, 0xfc, 0xd3, 0xe5, 0x1c, 0x94,
0x00, 0xe5, 0x1b, 0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0xaa, 0x1b, 0xab,
0x1c, 0x80, 0x09, 0xc3, 0xe4, 0x95, 0x1c, 0xfb, 0xe4, 0x95, 0x1b, 0xfa,
0xed, 0x2b, 0xfd, 0xec, 0x3a, 0xfc, 0xd3, 0xef, 0x94, 0x00, 0xee, 0x64,
0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x07, 0xc3, 0xe4, 0x9f, 0xff, 0xe4,
0x9e, 0xfe, 0xed, 0x2f, 0xff, 0xec, 0x3e, 0xfe, 0x22, 0x12, 0x6c, 0x24,
0x8f, 0x12, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x02, 0x39, 0x88, 0x90,
0x04, 0x15, 0xe0, 0xc3, 0x94, 0xbb, 0xe4, 0x94, 0x00, 0x40, 0x03, 0x02,
0x39, 0x88, 0x90, 0x04, 0x24, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x63,
0x70, 0x03, 0x02, 0x39, 0x88, 0x90, 0x04, 0x49, 0xe0, 0x70, 0x30, 0x7f,
0x38, 0x12, 0x78, 0xb8, 0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a,
0x12, 0x26, 0x4e, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x7f,
0x39, 0x12, 0x78, 0xb8, 0xee, 0x54, 0x03, 0xfe, 0xd0, 0x03, 0xd0, 0x02,
0xd0, 0x01, 0xd0, 0x00, 0xeb, 0x4f, 0xff, 0xea, 0x4e, 0x80, 0x71, 0x90,
0x04, 0x24, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xc3, 0x94, 0xf0, 0xee, 0x64,
0x80, 0x94, 0x7f, 0x40, 0x36, 0xd3, 0xef, 0x94, 0x0f, 0xee, 0x64, 0x80,
0x94, 0x80, 0x50, 0x2b, 0x7f, 0x34, 0x12, 0x78, 0xb8, 0xee, 0x33, 0x95,
0xe0, 0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xc0, 0x04, 0xc0, 0x05,
0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x35, 0x12, 0x78, 0xeb, 0xd0, 0x03, 0xd0,
0x02, 0xd0, 0x01, 0xd0, 0x00, 0xeb, 0x4f, 0xff, 0xea, 0x80, 0x29, 0x7f,
0x36, 0x12, 0x78, 0xb8, 0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a,
0x12, 0x26, 0x4e, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x7f,
0x37, 0x12, 0x78, 0xeb, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00,
0xeb, 0x4f, 0xff, 0xea, 0xfe, 0xe9, 0xfd, 0xe8, 0xfc, 0x12, 0x64, 0x3b,
0x75, 0xf0, 0x02, 0xe5, 0x38, 0xa4, 0x24, 0xf8, 0xf5, 0x82, 0xe5, 0xf0,
0x34, 0x7b, 0xf5, 0x83, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd, 0x90,
0x04, 0x77, 0xe0, 0xfb, 0x7a, 0x00, 0xed, 0x2b, 0xfd, 0xea, 0x3c, 0xfc,
0x74, 0x00, 0x2d, 0xf5, 0x82, 0x74, 0x01, 0x3c, 0xf5, 0x83, 0xef, 0xf0,
0xc3, 0x90, 0x04, 0x25, 0xe0, 0x94, 0x1f, 0x90, 0x04, 0x24, 0xe0, 0x64,
0x80, 0x94, 0x80, 0x50, 0x0d, 0x12, 0x6a, 0x6f, 0x12, 0x75, 0x3a, 0x90,
0x04, 0x77, 0xe5, 0x12, 0xf0, 0x22, 0x12, 0x78, 0x36, 0xd3, 0xef, 0x64,
0x80, 0x94, 0x61, 0x50, 0x03, 0x02, 0x39, 0x7f, 0x90, 0x04, 0x49, 0xe0,
0x70, 0x0c, 0x7f, 0xc1, 0x12, 0x6e, 0xc9, 0x7f, 0x01, 0x12, 0x6e, 0xc9,
0x80, 0x0e, 0x7f, 0x04, 0x12, 0x6e, 0xc9, 0x75, 0xa5, 0x02, 0x75, 0xa6,
0xff, 0x75, 0x9a, 0x32, 0x90, 0x04, 0x24, 0x74, 0xff, 0xf0, 0xa3, 0x74,
0xe1, 0xf0, 0x12, 0x78, 0x36, 0xef, 0x14, 0xff, 0x12, 0x73, 0x80, 0x12,
0x75, 0x3a, 0x90, 0x04, 0x77, 0xe5, 0x12, 0xf0, 0x75, 0xf0, 0x02, 0xe5,
0x38, 0xa4, 0x24, 0xf8, 0xf5, 0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83,
0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0xff, 0x90, 0x04, 0x77, 0xe0, 0xfd,
0x7c, 0x00, 0xef, 0x2d, 0xff, 0xec, 0x3e, 0xfe, 0x74, 0x00, 0x2f, 0xf5,
0x82, 0x74, 0x01, 0x3e, 0xf5, 0x83, 0xe4, 0xf0, 0xe5, 0x12, 0xc3, 0x94,
0xbf, 0x40, 0x04, 0x7f, 0x00, 0x80, 0x06, 0x90, 0x04, 0x77, 0xe0, 0x04,
0xff, 0x90, 0x04, 0x77, 0xef, 0xf0, 0x22, 0x90, 0x04, 0x24, 0xe4, 0xf0,
0xa3, 0x74, 0x63, 0xf0, 0x22, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xf0, 0x70,
0x03, 0x02, 0x3a, 0x57, 0x80, 0x00, 0x90, 0x04, 0x49, 0xe0, 0x60, 0x03,
0x02, 0x3a, 0xca, 0x90, 0x04, 0x87, 0xe0, 0x30, 0xe0, 0x03, 0x02, 0x3a,
0xca, 0x12, 0x71, 0x32, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78,
0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x05, 0x7f,
0x0c, 0x12, 0x74, 0x19, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78,
0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x64, 0x90,
0x04, 0x4c, 0xe0, 0x64, 0x01, 0x60, 0x1e, 0x90, 0x04, 0x7c, 0xe0, 0x60,
0x0b, 0x74, 0xff, 0x90, 0x04, 0x28, 0xf0, 0xa3, 0xf0, 0x02, 0x3a, 0x75,
0x12, 0x44, 0x84, 0x90, 0x04, 0x28, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x80,
0x78, 0x90, 0x04, 0x55, 0xe0, 0x70, 0x06, 0x90, 0x04, 0x28, 0xf0, 0xa3,
0xf0, 0x90, 0x04, 0x7c, 0xe0, 0x60, 0x10, 0x90, 0x04, 0x29, 0xe0, 0x24,
0xff, 0xf0, 0x90, 0x04, 0x28, 0xe0, 0x34, 0xff, 0xf0, 0x80, 0x0f, 0x12,
0x44, 0x84, 0x90, 0x04, 0x29, 0xe0, 0x2f, 0xf0, 0x90, 0x04, 0x28, 0xe0,
0x3e, 0xf0, 0x90, 0x04, 0x55, 0xe0, 0x04, 0xf0, 0xe0, 0x64, 0x08, 0x70,
0x70, 0x80, 0x66, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02,
0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x5b, 0x12, 0x75,
0x3a, 0x90, 0x04, 0x40, 0x74, 0x10, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70,
0x03, 0x7f, 0x02, 0x22, 0x90, 0x04, 0x4c, 0xe0, 0x64, 0x01, 0x60, 0x12,
0x7f, 0x38, 0x12, 0x78, 0xb8, 0x90, 0x04, 0x28, 0xee, 0xf0, 0xa3, 0xef,
0xf0, 0x12, 0x54, 0x72, 0x80, 0x2f, 0x90, 0x04, 0x55, 0xe0, 0x70, 0x06,
0x90, 0x04, 0x28, 0xf0, 0xa3, 0xf0, 0x7f, 0x38, 0x12, 0x78, 0xb8, 0x90,
0x04, 0x29, 0xe0, 0x2f, 0xf0, 0x90, 0x04, 0x28, 0xe0, 0x3e, 0xf0, 0x90,
0x04, 0x55, 0xe0, 0x04, 0xf0, 0xe0, 0xb4, 0x08, 0x08, 0x12, 0x54, 0x72,
0xe4, 0x90, 0x04, 0x55, 0xf0, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0,
0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x03,
0x02, 0x3b, 0x42, 0x90, 0x04, 0x5c, 0xe0, 0x70, 0x03, 0x02, 0x39, 0xc4,
0x80, 0x78, 0x90, 0x04, 0x49, 0xe0, 0x64, 0x01, 0x70, 0x6a, 0x90, 0x04,
0x87, 0xe0, 0x20, 0xe0, 0x63, 0x12, 0x71, 0x32, 0x90, 0x04, 0x4c, 0xe0,
0x64, 0x01, 0x60, 0x10, 0x12, 0x61, 0x2c, 0x90, 0x04, 0x28, 0xee, 0xf0,
0xa3, 0xef, 0xf0, 0x12, 0x54, 0x72, 0x80, 0x2d, 0x90, 0x04, 0x55, 0xe0,
0x70, 0x06, 0x90, 0x04, 0x28, 0xf0, 0xa3, 0xf0, 0x12, 0x61, 0x2c, 0x90,
0x04, 0x29, 0xe0, 0x2f, 0xf0, 0x90, 0x04, 0x28, 0xe0, 0x3e, 0xf0, 0x90,
0x04, 0x55, 0xe0, 0x04, 0xf0, 0xe0, 0xb4, 0x08, 0x08, 0x12, 0x54, 0x72,
0xe4, 0x90, 0x04, 0x55, 0xf0, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0,
0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x0e,
0x90, 0x04, 0x5c, 0xe0, 0x60, 0xa2, 0x80, 0x06, 0x90, 0x04, 0x5c, 0x74,
0x01, 0xf0, 0x90, 0x04, 0x40, 0x74, 0x33, 0xf0, 0x7f, 0x00, 0x22, 0xe4,
0xf5, 0x12, 0x90, 0x04, 0x49, 0xe0, 0xff, 0x60, 0x19, 0xb4, 0x01, 0x13,
0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13,
0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x03, 0x02, 0x3c, 0x8d, 0x90, 0x04,
0x87, 0xe0, 0xff, 0x13, 0x13, 0x54, 0x3f, 0x30, 0xe0, 0x03, 0x02, 0x3c,
0x8d, 0x90, 0x00, 0x5f, 0xe0, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0,
0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x90, 0x04, 0x53,
0x30, 0xe0, 0x05, 0x74, 0x05, 0xf0, 0x80, 0x03, 0x74, 0x14, 0xf0, 0x90,
0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce,
0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x0b, 0x12, 0x77, 0xa4, 0x90, 0x04, 0x20,
0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x12, 0x69, 0x1a, 0x90, 0x04, 0x24, 0xee,
0xf0, 0xa3, 0xef, 0xf0, 0x12, 0x78, 0xc3, 0x90, 0x04, 0x56, 0xef, 0xf0,
0xf5, 0x12, 0x90, 0x00, 0x5f, 0xe0, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3,
0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0,
0x66, 0x90, 0x04, 0x7c, 0xe0, 0x60, 0x0b, 0x90, 0x04, 0x56, 0xe0, 0xc3,
0x94, 0x0f, 0x50, 0x02, 0x80, 0x65, 0x90, 0x04, 0x20, 0xe0, 0xfe, 0xa3,
0xe0, 0xff, 0x90, 0x04, 0x25, 0xe0, 0x2f, 0xfd, 0x90, 0x04, 0x24, 0xe0,
0x3e, 0xfc, 0xc3, 0xed, 0x94, 0xee, 0xec, 0x94, 0x02, 0x50, 0x1a, 0x90,
0x04, 0x82, 0xe0, 0x70, 0x14, 0xc3, 0xef, 0x94, 0x77, 0xee, 0x94, 0x01,
0x50, 0x0b, 0x90, 0x04, 0x56, 0xe0, 0xc3, 0x94, 0x2d, 0x50, 0x02, 0x80,
0x2e, 0xd3, 0xed, 0x94, 0x39, 0xec, 0x94, 0x03, 0x50, 0x06, 0x90, 0x04,
0x82, 0xe0, 0x60, 0x37, 0x90, 0x04, 0x53, 0xe0, 0xff, 0x90, 0x04, 0x56,
0xe0, 0xd3, 0x9f, 0x40, 0x2a, 0x80, 0x25, 0x90, 0x04, 0x82, 0xe0, 0xff,
0x70, 0x0e, 0x90, 0x04, 0x56, 0xe0, 0xc3, 0x94, 0x2d, 0x50, 0x18, 0xe0,
0x04, 0xf0, 0x80, 0x13, 0xef, 0x60, 0x10, 0x90, 0x04, 0x53, 0xe0, 0xff,
0x90, 0x04, 0x56, 0xe0, 0xd3, 0x9f, 0x40, 0x03, 0xe0, 0x14, 0xf0, 0x90,
0x04, 0x56, 0xe0, 0xff, 0x12, 0x78, 0xf3, 0xe0, 0xfe, 0x65, 0x12, 0x60,
0x08, 0x90, 0x04, 0x5e, 0xe0, 0xfd, 0xb4, 0x01, 0x09, 0x90, 0x04, 0x5e,
0x74, 0x01, 0xf0, 0x7f, 0x00, 0x22, 0xee, 0xd3, 0x95, 0x12, 0x40, 0x23,
0xed, 0x64, 0x04, 0x60, 0x07, 0x90, 0x04, 0x4c, 0xe0, 0xb4, 0x01, 0x08,
0x90, 0x04, 0x5e, 0x74, 0x02, 0xf0, 0x80, 0x06, 0x90, 0x04, 0x5e, 0x74,
0x03, 0xf0, 0x90, 0x04, 0x56, 0xe0, 0xc3, 0x95, 0x12, 0xff, 0x22, 0x90,
0x04, 0x5e, 0xe0, 0x64, 0x03, 0x60, 0x07, 0x90, 0x04, 0x4c, 0xe0, 0xb4,
0x01, 0x08, 0x90, 0x04, 0x5e, 0x74, 0x02, 0xf0, 0x80, 0x06, 0x90, 0x04,
0x5e, 0x74, 0x04, 0xf0, 0x90, 0x04, 0x56, 0xe0, 0xff, 0xc3, 0xe5, 0x12,
0x9f, 0xf4, 0x04, 0xff, 0x22, 0x12, 0x6c, 0x24, 0x8f, 0x12, 0x12, 0x78,
0xac, 0xef, 0x70, 0x03, 0x02, 0x3e, 0x84, 0x90, 0x04, 0x15, 0xe0, 0xc3,
0x94, 0xbb, 0xe4, 0x94, 0x00, 0x40, 0x03, 0x02, 0x3e, 0x84, 0x90, 0x04,
0x24, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x63, 0x70, 0x03, 0x02, 0x3e,
0x84, 0x90, 0x04, 0x49, 0xe0, 0x70, 0x30, 0x7f, 0x38, 0x12, 0x78, 0xb8,
0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xc0,
0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x39, 0x12, 0x78, 0xb8,
0xee, 0x54, 0x03, 0xfe, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00,
0xeb, 0x4f, 0xff, 0xea, 0x4e, 0x80, 0x71, 0x90, 0x04, 0x24, 0xe0, 0xfe,
0xa3, 0xe0, 0xff, 0xc3, 0x94, 0xf0, 0xee, 0x64, 0x80, 0x94, 0x7f, 0x40,
0x36, 0xd3, 0xef, 0x94, 0x0f, 0xee, 0x64, 0x80, 0x94, 0x80, 0x50, 0x2b,
0x7f, 0x34, 0x12, 0x78, 0xb8, 0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78,
0x0a, 0x12, 0x26, 0x4e, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07,
0x7f, 0x35, 0x12, 0x78, 0xeb, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
0x00, 0xeb, 0x4f, 0xff, 0xea, 0x80, 0x29, 0x7f, 0x36, 0x12, 0x78, 0xb8,
0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xc0,
0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x37, 0x12, 0x78, 0xeb,
0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xeb, 0x4f, 0xff, 0xea,
0xfe, 0xe9, 0xfd, 0xe8, 0xfc, 0x12, 0x64, 0x3b, 0x75, 0xf0, 0x02, 0xe5,
0x38, 0xa4, 0x24, 0xf8, 0xf5, 0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83,
0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd, 0x90, 0x04, 0x77, 0xe0, 0xfb,
0x7a, 0x00, 0xed, 0x2b, 0xfd, 0xea, 0x3c, 0xfc, 0x74, 0x00, 0x2d, 0xf5,
0x82, 0x74, 0x01, 0x3c, 0xf5, 0x83, 0xef, 0xf0, 0x12, 0x78, 0x36, 0xd3,
0xef, 0x64, 0x80, 0x94, 0x61, 0x50, 0x73, 0xc3, 0x90, 0x04, 0x25, 0xe0,
0x94, 0x1f, 0x90, 0x04, 0x24, 0xe0, 0x64, 0x80, 0x94, 0x80, 0x50, 0x58,
0x12, 0x6a, 0x6f, 0x7f, 0x1f, 0x12, 0x73, 0x80, 0x12, 0x75, 0x3a, 0x90,
0x04, 0x77, 0xe5, 0x12, 0xf0, 0x75, 0xf0, 0x02, 0xe5, 0x38, 0xa4, 0x24,
0xf8, 0xf5, 0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83, 0xe4, 0x93, 0xfe,
0x74, 0x01, 0x93, 0xff, 0x90, 0x04, 0x77, 0xe0, 0xfd, 0x7c, 0x00, 0xef,
0x2d, 0xff, 0xec, 0x3e, 0xfe, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0x74, 0x01,
0x3e, 0xf5, 0x83, 0xe4, 0xf0, 0xe5, 0x12, 0xc3, 0x94, 0xbf, 0x40, 0x04,
0x7f, 0x00, 0x80, 0x06, 0x90, 0x04, 0x77, 0xe0, 0x04, 0xff, 0x90, 0x04,
0x77, 0xef, 0xf0, 0x22, 0x90, 0x04, 0x24, 0xe4, 0xf0, 0xa3, 0x74, 0x63,
0xf0, 0x22, 0x12, 0x78, 0x36, 0xef, 0x14, 0xff, 0x12, 0x73, 0x80, 0x12,
0x75, 0x3a, 0x90, 0x04, 0x77, 0xe5, 0x12, 0xf0, 0x22, 0x75, 0xa5, 0x01,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfe, 0x75, 0x9a, 0x40, 0x75, 0xa5, 0xc0,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0x3f, 0x75, 0x9a, 0x20, 0x90, 0x00, 0x50,
0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x7e, 0x00, 0x54, 0x1f, 0xff, 0xd3,
0x94, 0x10, 0xee, 0x94, 0x00, 0x40, 0x1e, 0x90, 0x04, 0x7f, 0xe0, 0xc4,
0x54, 0x0f, 0x20, 0xe0, 0x09, 0xd3, 0xef, 0x94, 0x16, 0xee, 0x94, 0x00,
0x40, 0x0b, 0x90, 0x04, 0x88, 0xe0, 0xc4, 0x13, 0x54, 0x07, 0x30, 0xe0,
0x04, 0x7f, 0x01, 0x80, 0x02, 0x7f, 0x00, 0xef, 0x25, 0xe0, 0x54, 0x02,
0xf5, 0xa4, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x7e,
0x00, 0x54, 0x1f, 0xff, 0xd3, 0x94, 0x10, 0xee, 0x94, 0x00, 0x40, 0x20,
0x90, 0x04, 0x7f, 0xe0, 0xc4, 0x54, 0x0f, 0x20, 0xe0, 0x09, 0xd3, 0xef,
0x94, 0x16, 0xee, 0x94, 0x00, 0x40, 0x0d, 0x90, 0x04, 0x88, 0xe0, 0xc4,
0x13, 0x54, 0x07, 0x30, 0xe0, 0x02, 0x80, 0x00, 0x74, 0x04, 0xf5, 0xa5,
0x75, 0xa6, 0xfd, 0x75, 0xa7, 0x93, 0x75, 0x9a, 0x21, 0x75, 0xa4, 0x20,
0x75, 0xa5, 0x20, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x22,
0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x7e, 0x00, 0x54,
0x1f, 0xff, 0xd3, 0x94, 0x10, 0xee, 0x94, 0x00, 0x40, 0x1f, 0x90, 0x04,
0x7f, 0xe0, 0xc4, 0x54, 0x0f, 0x20, 0xe0, 0x09, 0xd3, 0xef, 0x94, 0x16,
0xee, 0x94, 0x00, 0x40, 0x0c, 0x90, 0x04, 0x88, 0xe0, 0xc4, 0x13, 0x13,
0x54, 0x03, 0x30, 0xe0, 0x04, 0x7f, 0x01, 0x80, 0x02, 0x7f, 0x00, 0xef,
0x25, 0xe0, 0x54, 0x02, 0xf5, 0xa4, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13,
0xa3, 0xe0, 0x13, 0x7e, 0x00, 0x54, 0x1f, 0xff, 0xd3, 0x94, 0x10, 0xee,
0x94, 0x00, 0x40, 0x21, 0x90, 0x04, 0x7f, 0xe0, 0xc4, 0x54, 0x0f, 0x20,
0xe0, 0x09, 0xd3, 0xef, 0x94, 0x16, 0xee, 0x94, 0x00, 0x40, 0x0e, 0x90,
0x04, 0x88, 0xe0, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x30, 0xe0, 0x02, 0x80,
0x00, 0x74, 0x04, 0xf5, 0xa5, 0x75, 0xa6, 0xfd, 0x75, 0xa7, 0x93, 0x75,
0x9a, 0x23, 0x75, 0xa4, 0x20, 0x75, 0xa5, 0x20, 0x75, 0xa6, 0xc0, 0x75,
0xa7, 0xc0, 0x75, 0x9a, 0x24, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0x93, 0x75, 0x9a, 0x25, 0x75, 0xa4, 0x20, 0x75, 0xa5, 0x20, 0x75,
0xa6, 0xc0, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x26, 0x75, 0xa5, 0x04, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0x93, 0x75, 0x9a, 0x27, 0x75, 0xa4, 0x20, 0x75,
0xa5, 0x20, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x28, 0x75,
0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x93, 0x75, 0x9a, 0x29, 0x75,
0xa4, 0x20, 0x75, 0xa5, 0x20, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xc0, 0x75,
0x9a, 0x2a, 0x22, 0x90, 0x04, 0x00, 0xa3, 0xe0, 0xff, 0x7d, 0x02, 0x8f,
0x1a, 0x90, 0x00, 0x5a, 0xe0, 0xf5, 0x1b, 0xa3, 0xe0, 0xf5, 0x1c, 0xc3,
0xe5, 0x1c, 0x94, 0xf8, 0xe5, 0x1b, 0x94, 0x02, 0x40, 0x03, 0x02, 0x41,
0x9f, 0x90, 0x00, 0x65, 0xe0, 0x64, 0x01, 0x70, 0x03, 0x02, 0x41, 0x9f,
0x90, 0x04, 0x05, 0xe0, 0xc3, 0x9d, 0x50, 0x03, 0x02, 0x41, 0x9f, 0x90,
0x00, 0x5d, 0xe0, 0xb4, 0xff, 0x15, 0xe5, 0x1c, 0x24, 0x0c, 0xff, 0xe4,
0x35, 0x1b, 0xfe, 0xd3, 0xef, 0x94, 0xf8, 0xee, 0x94, 0x02, 0x40, 0x03,
0x02, 0x41, 0x9f, 0xe5, 0x33, 0x60, 0x03, 0x02, 0x41, 0x34, 0x12, 0x76,
0xf7, 0x8e, 0x34, 0x8f, 0x35, 0x90, 0x00, 0x60, 0xe0, 0x30, 0xe0, 0x11,
0x54, 0xfe, 0xf0, 0x90, 0x00, 0x67, 0xe0, 0x04, 0xf0, 0x70, 0x06, 0x90,
0x00, 0x66, 0xe0, 0x04, 0xf0, 0xd3, 0x90, 0x00, 0x67, 0xe0, 0x94, 0x00,
0x90, 0x00, 0x66, 0xe0, 0x94, 0x00, 0x50, 0x03, 0x02, 0x41, 0x34, 0x74,
0x02, 0x25, 0x1c, 0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83, 0x74,
0xff, 0xf0, 0x90, 0x00, 0x66, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xec, 0xff,
0x74, 0x01, 0x25, 0x1c, 0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83,
0xef, 0xf0, 0x74, 0x00, 0x25, 0x1c, 0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b,
0xf5, 0x83, 0xed, 0xf0, 0x74, 0x03, 0x25, 0x1c, 0xf5, 0x1c, 0xe4, 0x35,
0x1b, 0xf5, 0x1b, 0xc3, 0xe5, 0x1c, 0x94, 0xf8, 0xe5, 0x1b, 0x94, 0x02,
0x40, 0x3f, 0xe4, 0xf5, 0x1d, 0xe5, 0x1c, 0x24, 0x08, 0xff, 0xe5, 0x1b,
0x34, 0xfd, 0xfe, 0xc3, 0xe5, 0x1d, 0x9f, 0xe4, 0x9e, 0x50, 0x1e, 0x74,
0xf8, 0x25, 0x1d, 0xf5, 0x82, 0xe4, 0x34, 0x03, 0xf5, 0x83, 0xe0, 0xff,
0x74, 0x00, 0x25, 0x1d, 0xf5, 0x82, 0xe4, 0x34, 0x01, 0xf5, 0x83, 0xef,
0xf0, 0x05, 0x1d, 0x80, 0xd0, 0x74, 0x08, 0x25, 0x1c, 0xf5, 0x1c, 0x74,
0xfd, 0x35, 0x1b, 0xf5, 0x1b, 0xe4, 0x90, 0x00, 0x66, 0xf0, 0xa3, 0xf0,
0x74, 0x00, 0x25, 0x1c, 0xf5, 0x82, 0x74, 0x01, 0x35, 0x1b, 0xf5, 0x83,
0xe5, 0x1a, 0xf0, 0x05, 0x1c, 0xe5, 0x1c, 0x70, 0x02, 0x05, 0x1b, 0xc3,
0x94, 0xf8, 0xe5, 0x1b, 0x94, 0x02, 0x40, 0x3f, 0xe4, 0xf5, 0x1d, 0xe5,
0x1c, 0x24, 0x08, 0xff, 0xe5, 0x1b, 0x34, 0xfd, 0xfe, 0xc3, 0xe5, 0x1d,
0x9f, 0xe4, 0x9e, 0x50, 0x1e, 0x74, 0xf8, 0x25, 0x1d, 0xf5, 0x82, 0xe4,
0x34, 0x03, 0xf5, 0x83, 0xe0, 0xff, 0x74, 0x00, 0x25, 0x1d, 0xf5, 0x82,
0xe4, 0x34, 0x01, 0xf5, 0x83, 0xef, 0xf0, 0x05, 0x1d, 0x80, 0xd0, 0x74,
0x08, 0x25, 0x1c, 0xf5, 0x1c, 0x74, 0xfd, 0x35, 0x1b, 0xf5, 0x1b, 0x05,
0x33, 0x90, 0x00, 0x5a, 0xe5, 0x1b, 0xf0, 0xa3, 0xe5, 0x1c, 0xf0, 0x22,
0x90, 0x04, 0x45, 0xe0, 0x90, 0x04, 0x4f, 0xf0, 0x90, 0x04, 0x0d, 0xe0,
0xff, 0xa3, 0xe0, 0xc3, 0x9f, 0xff, 0xe4, 0x94, 0x00, 0xa2, 0xe7, 0x13,
0xfe, 0xef, 0x13, 0xff, 0x90, 0x04, 0x24, 0xee, 0xf0, 0xa3, 0xef, 0xf0,
0x90, 0x04, 0x4c, 0xe0, 0x64, 0x01, 0x70, 0x36, 0x90, 0x04, 0x7d, 0xe0,
0xc3, 0x94, 0x07, 0x40, 0x51, 0xe4, 0xf0, 0x90, 0x04, 0x24, 0xe0, 0xfc,
0xa3, 0xe0, 0xfd, 0xd3, 0x94, 0x0c, 0xec, 0x64, 0x80, 0x94, 0x80, 0x40,
0x07, 0x90, 0x04, 0x45, 0xe0, 0x14, 0x80, 0x32, 0xc3, 0xed, 0x94, 0xf4,
0xec, 0x64, 0x80, 0x94, 0x7f, 0x50, 0x2b, 0x90, 0x04, 0x45, 0xe0, 0x04,
0x80, 0x20, 0x90, 0x04, 0x25, 0xe0, 0x24, 0x04, 0xff, 0x90, 0x04, 0x24,
0xe0, 0x34, 0x00, 0xfe, 0xef, 0x78, 0x03, 0xce, 0xa2, 0xe7, 0x13, 0xce,
0x13, 0xd8, 0xf8, 0xff, 0x90, 0x04, 0x45, 0xe0, 0xc3, 0x9f, 0x90, 0x04,
0x4f, 0xf0, 0x90, 0x04, 0x4f, 0xe0, 0xff, 0xc3, 0x64, 0x80, 0x94, 0x98,
0x50, 0x05, 0x74, 0x18, 0xf0, 0x80, 0x0e, 0xd3, 0xef, 0x64, 0x80, 0x94,
0xac, 0x40, 0x06, 0x90, 0x04, 0x4f, 0x74, 0x2c, 0xf0, 0x90, 0x04, 0x4f,
0xe0, 0xff, 0x90, 0x04, 0x45, 0xe0, 0xfe, 0x6f, 0x70, 0x03, 0x02, 0x43,
0x1a, 0xee, 0xfd, 0x33, 0x95, 0xe0, 0xfc, 0xef, 0x33, 0x95, 0xe0, 0xfe,
0xc3, 0xef, 0x9d, 0xff, 0xee, 0x9c, 0xfe, 0xef, 0x78, 0x03, 0xc3, 0x33,
0xce, 0x33, 0xce, 0xd8, 0xf9, 0xff, 0x90, 0x04, 0x24, 0xee, 0xf0, 0xa3,
0xef, 0xf0, 0x90, 0x04, 0x4f, 0xe0, 0xff, 0x90, 0x04, 0x45, 0xf0, 0x12,
0x63, 0x09, 0x90, 0x04, 0x0e, 0xe0, 0xff, 0x90, 0x04, 0x25, 0xe0, 0x2f,
0xff, 0x90, 0x04, 0x24, 0xe0, 0x34, 0x00, 0xfe, 0x90, 0x04, 0x26, 0xf0,
0xa3, 0xef, 0xf0, 0xc3, 0xee, 0x64, 0x80, 0x94, 0x80, 0x50, 0x09, 0xe4,
0x90, 0x04, 0x26, 0xf0, 0xa3, 0xf0, 0x80, 0x17, 0xd3, 0x90, 0x04, 0x27,
0xe0, 0x94, 0xf8, 0x90, 0x04, 0x26, 0xe0, 0x64, 0x80, 0x94, 0x80, 0x40,
0x06, 0xe4, 0xf0, 0xa3, 0x74, 0xf8, 0xf0, 0x90, 0x04, 0x26, 0xa3, 0xe0,
0x90, 0x04, 0x0e, 0xf0, 0x90, 0x04, 0x0d, 0xe0, 0xff, 0x90, 0x04, 0x24,
0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xc3, 0xef, 0x9d, 0xff, 0xe4, 0x9c, 0xfe,
0xa3, 0xf0, 0xa3, 0xef, 0xf0, 0xc3, 0xee, 0x64, 0x80, 0x94, 0x80, 0x50,
0x09, 0xe4, 0x90, 0x04, 0x26, 0xf0, 0xa3, 0xf0, 0x80, 0x17, 0xd3, 0x90,
0x04, 0x27, 0xe0, 0x94, 0xf8, 0x90, 0x04, 0x26, 0xe0, 0x64, 0x80, 0x94,
0x80, 0x40, 0x06, 0xe4, 0xf0, 0xa3, 0x74, 0xf8, 0xf0, 0x90, 0x04, 0x26,
0xa3, 0xe0, 0x90, 0x04, 0x0d, 0xf0, 0x7f, 0x00, 0x22, 0x8d, 0x82, 0x8c,
0x83, 0xad, 0x07, 0x79, 0x04, 0xe4, 0xfc, 0x7a, 0x01, 0xd3, 0xe5, 0x23,
0x64, 0x80, 0xf8, 0xed, 0x64, 0x80, 0x98, 0x50, 0x22, 0xe5, 0x23, 0x64,
0x80, 0xf8, 0xeb, 0x64, 0x80, 0x98, 0x50, 0x17, 0xc3, 0xe5, 0x22, 0x64,
0x80, 0xf8, 0xed, 0x64, 0x80, 0x98, 0x40, 0x0b, 0xe5, 0x22, 0x64, 0x80,
0xf8, 0xeb, 0x64, 0x80, 0x98, 0x50, 0x03, 0x7f, 0x00, 0x22, 0xe5, 0x24,
0x6d, 0x70, 0x53, 0xe5, 0x82, 0x45, 0x83, 0x70, 0x02, 0xff, 0x22, 0xd3,
0xeb, 0x64, 0x80, 0xf8, 0xed, 0x64, 0x80, 0x98, 0x40, 0x02, 0x7a, 0xff,
0xd3, 0xe5, 0x82, 0x94, 0x00, 0xe5, 0x83, 0x64, 0x80, 0x94, 0x80, 0x40,
0x06, 0xae, 0x83, 0xaf, 0x82, 0x80, 0x09, 0xc3, 0xe4, 0x95, 0x82, 0xff,
0xe4, 0x95, 0x83, 0xfe, 0x8e, 0x25, 0x8f, 0x26, 0xd3, 0xe5, 0x21, 0x94,
0x00, 0xe5, 0x20, 0x64, 0x80, 0x94, 0x80, 0x40, 0x06, 0xae, 0x20, 0xaf,
0x21, 0x80, 0x61, 0xc3, 0xe4, 0x95, 0x21, 0xff, 0xe4, 0x95, 0x20, 0xfe,
0x80, 0x56, 0xe5, 0x24, 0x6b, 0x70, 0x57, 0xe5, 0x21, 0x45, 0x20, 0x70,
0x02, 0xff, 0x22, 0xd3, 0xed, 0x64, 0x80, 0xf8, 0xeb, 0x64, 0x80, 0x98,
0x40, 0x02, 0x7a, 0xff, 0xd3, 0xe5, 0x21, 0x94, 0x00, 0xe5, 0x20, 0x64,
0x80, 0x94, 0x80, 0x40, 0x06, 0xae, 0x20, 0xaf, 0x21, 0x80, 0x09, 0xc3,
0xe4, 0x95, 0x21, 0xff, 0xe4, 0x95, 0x20, 0xfe, 0x8e, 0x25, 0x8f, 0x26,
0xd3, 0xe5, 0x82, 0x94, 0x00, 0xe5, 0x83, 0x64, 0x80, 0x94, 0x80, 0x40,
0x06, 0xae, 0x83, 0xaf, 0x82, 0x80, 0x09, 0xc3, 0xe4, 0x95, 0x82, 0xff,
0xe4, 0x95, 0x83, 0xfe, 0x8e, 0x27, 0x8f, 0x28, 0x80, 0x03, 0x7f, 0x00,
0x22, 0xe4, 0xfd, 0xed, 0xd3, 0x99, 0x50, 0x50, 0xc3, 0xe5, 0x26, 0x95,
0x28, 0xe5, 0x27, 0x64, 0x80, 0xf8, 0xe5, 0x25, 0x64, 0x80, 0x98, 0xec,
0x50, 0x1e, 0x25, 0xe0, 0xfc, 0xc3, 0xe5, 0x28, 0x95, 0x26, 0xcf, 0xe5,
0x27, 0x95, 0x25, 0xcf, 0x24, 0x01, 0xcf, 0x34, 0x00, 0xa2, 0xe7, 0x13,
0xf5, 0x27, 0xef, 0x13, 0xf5, 0x28, 0x80, 0x1d, 0x25, 0xe0, 0x04, 0xfc,
0xc3, 0xe5, 0x26, 0x95, 0x28, 0xcf, 0xe5, 0x25, 0x95, 0x27, 0xcf, 0x24,
0x01, 0xcf, 0x34, 0x00, 0xa2, 0xe7, 0x13, 0xf5, 0x25, 0xef, 0x13, 0xf5,
0x26, 0x0d, 0x80, 0xab, 0xec, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0x24,
0x01, 0xff, 0xe4, 0x3e, 0xa2, 0xe7, 0x13, 0xef, 0x13, 0xfc, 0xba, 0xff,
0x04, 0xf4, 0x04, 0xff, 0x22, 0xaf, 0x04, 0x22, 0x7f, 0x3b, 0x12, 0x78,
0xe6, 0xef, 0x54, 0x07, 0xff, 0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f,
0x3b, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f,
0xfd, 0xd0, 0xe0, 0x2d, 0xff, 0xd0, 0xe0, 0x34, 0x00, 0xc3, 0x13, 0xfe,
0xef, 0x13, 0xff, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3b, 0x12, 0x78, 0xeb,
0xef, 0x54, 0x3f, 0xfd, 0xd0, 0xe0, 0x2d, 0xf5, 0x13, 0xd0, 0xe0, 0x34,
0x00, 0xf5, 0x12, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x1f, 0xff,
0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef,
0x54, 0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f, 0xfd, 0xd0, 0xe0, 0x2d, 0xf5,
0x1b, 0xd0, 0xe0, 0x34, 0x00, 0xf5, 0x1a, 0x7f, 0x3c, 0x12, 0x78, 0xeb,
0xef, 0x54, 0x7f, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x64, 0x01, 0x70, 0x0a,
0xc3, 0x95, 0x1b, 0xff, 0xe4, 0x95, 0x1a, 0xfe, 0x80, 0x04, 0xae, 0x1a,
0xaf, 0x1b, 0x8e, 0x16, 0x8f, 0x17, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef,
0x54, 0x1f, 0xff, 0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3c, 0x12,
0x78, 0xe6, 0xef, 0x54, 0x07, 0xfd, 0xd0, 0xe0, 0x2d, 0xf5, 0x1d, 0xd0,
0xe0, 0x34, 0x00, 0xf5, 0x1c, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54,
0x3f, 0xc4, 0x13, 0x54, 0x07, 0x64, 0x01, 0x70, 0x0a, 0xc3, 0x95, 0x1d,
0xff, 0xe4, 0x95, 0x1c, 0xfe, 0x80, 0x04, 0xae, 0x1c, 0xaf, 0x1d, 0xe5,
0x17, 0x2f, 0xff, 0xe5, 0x16, 0x3e, 0xa2, 0xe7, 0x13, 0xf5, 0x14, 0xef,
0x13, 0xf5, 0x15, 0x7f, 0x3d, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff,
0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33, 0x95,
0xe0, 0xf5, 0x18, 0x8f, 0x19, 0xe5, 0x15, 0x25, 0x19, 0xf5, 0x1f, 0xe5,
0x14, 0x35, 0x18, 0xf5, 0x1e, 0x7f, 0x3d, 0x12, 0x78, 0xb8, 0xee, 0x54,
0x07, 0xfe, 0x7d, 0x00, 0x7c, 0x04, 0x12, 0x77, 0xe0, 0xef, 0x78, 0x06,
0xce, 0xa2, 0xe7, 0x13, 0xce, 0x13, 0xd8, 0xf8, 0xff, 0x33, 0x95, 0xe0,
0xfe, 0xef, 0x25, 0xe0, 0xfd, 0xee, 0x33, 0xfc, 0xe5, 0x19, 0x25, 0xe0,
0xff, 0xe5, 0x18, 0x33, 0xfe, 0xe5, 0x1f, 0x2f, 0xcf, 0xe5, 0x1e, 0x3e,
0xcf, 0x2d, 0xcf, 0x3c, 0xfe, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3d, 0x12,
0x78, 0xb8, 0xef, 0x78, 0x0b, 0xce, 0xa2, 0xe7, 0x13, 0xce, 0x13, 0xd8,
0xf8, 0xfd, 0x33, 0x95, 0xe0, 0xfc, 0xd0, 0xe0, 0x2d, 0xff, 0xd0, 0xe0,
0x3c, 0xfe, 0x90, 0x00, 0x5f, 0xe0, 0x22, 0x7f, 0x2d, 0x12, 0x78, 0xf3,
0x12, 0x78, 0xc3, 0x90, 0x04, 0x56, 0xef, 0xf0, 0x75, 0xa4, 0x08, 0x75,
0xa6, 0xf6, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x40, 0xe4, 0xff, 0x12, 0x73,
0x80, 0x90, 0x04, 0x00, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xae, 0x04, 0x78,
0x07, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x32, 0x90,
0x04, 0x06, 0xe0, 0x20, 0xe0, 0x2b, 0xed, 0xae, 0x04, 0x78, 0x02, 0xce,
0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x10, 0x90, 0x04, 0x89,
0xe0, 0x60, 0x05, 0x75, 0xa4, 0x01, 0x80, 0x08, 0x75, 0xa4, 0x04, 0x80,
0x03, 0x75, 0xa4, 0x07, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x41, 0x90, 0x04, 0x49, 0xe0, 0x60, 0x24, 0x14, 0x60, 0x18, 0x24, 0xfb,
0x60, 0x08, 0x24, 0xfe, 0x60, 0x04, 0x24, 0x05, 0x70, 0x4a, 0x90, 0x04,
0x45, 0x74, 0x2a, 0xf0, 0xa3, 0x74, 0x15, 0xf0, 0x80, 0x47, 0xe4, 0x90,
0x04, 0x45, 0xf0, 0xa3, 0xf0, 0x80, 0x3e, 0x90, 0x04, 0x04, 0xe0, 0xff,
0x30, 0xe7, 0x08, 0x54, 0x7f, 0x90, 0x04, 0x45, 0xf0, 0x80, 0x1e, 0x90,
0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce,
0x13, 0xd8, 0xf9, 0x90, 0x04, 0x45, 0x30, 0xe0, 0x05, 0x74, 0x24, 0xf0,
0x80, 0x03, 0x74, 0x20, 0xf0, 0xe4, 0x90, 0x04, 0x46, 0xf0, 0x80, 0x09,
0x90, 0x04, 0x45, 0x74, 0x20, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x00, 0x50,
0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x54, 0x1f, 0xc3, 0x94, 0x05, 0xe4,
0x94, 0x00, 0x90, 0x04, 0x6d, 0x50, 0x05, 0x74, 0xff, 0xf0, 0x80, 0x03,
0x74, 0xfe, 0xf0, 0x90, 0x04, 0x45, 0xe0, 0xff, 0x12, 0x63, 0x09, 0x90,
0x04, 0x46, 0xe0, 0xff, 0x12, 0x5f, 0x3c, 0x90, 0x04, 0x00, 0xe0, 0xfe,
0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30,
0xe0, 0x03, 0x12, 0x3e, 0x85, 0x90, 0x04, 0x49, 0xe0, 0x64, 0x01, 0x70,
0x1f, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3,
0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x0c, 0x75, 0xa4, 0x01, 0x75,
0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x98, 0x75, 0xa4, 0x20, 0x75,
0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10, 0x90, 0x04, 0x44, 0x74,
0x01, 0xf0, 0x22, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xe0, 0x60, 0x53, 0x14,
0x70, 0x03, 0x02, 0x48, 0x59, 0x80, 0x00, 0x12, 0x71, 0x32, 0x90, 0x04,
0x49, 0xe0, 0x60, 0x03, 0x02, 0x48, 0x15, 0x90, 0x04, 0x00, 0xe0, 0xfe,
0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20,
0xe0, 0x03, 0x02, 0x48, 0x15, 0x90, 0x04, 0x50, 0x74, 0x01, 0xf0, 0xe4,
0xa3, 0xf0, 0x90, 0x04, 0x50, 0xe0, 0xff, 0x12, 0x6b, 0x4d, 0xef, 0x60,
0x27, 0x12, 0x6c, 0xf7, 0xe4, 0x90, 0x04, 0x4d, 0xf0, 0x90, 0x04, 0x4b,
0xf0, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x40, 0x74, 0x20, 0xf0, 0x12, 0x78,
0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0x12, 0x18, 0xe3, 0x90, 0x04,
0x4d, 0xe0, 0x60, 0xe5, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0,
0x13, 0x7e, 0x00, 0x54, 0x1f, 0xff, 0xd3, 0x94, 0x10, 0xee, 0x94, 0x00,
0x40, 0x40, 0x90, 0x04, 0x7f, 0xe0, 0xc4, 0x54, 0x0f, 0x20, 0xe0, 0x09,
0xd3, 0xef, 0x94, 0x16, 0xee, 0x94, 0x00, 0x40, 0x2d, 0x90, 0x04, 0x50,
0xe0, 0xff, 0xb4, 0x01, 0x0b, 0x90, 0x04, 0x88, 0xe0, 0xc4, 0x13, 0x54,
0x07, 0x30, 0xe0, 0x10, 0xef, 0xb4, 0x02, 0x16, 0x90, 0x04, 0x88, 0xe0,
0xc4, 0x13, 0x13, 0x54, 0x03, 0x20, 0xe0, 0x0a, 0x90, 0x04, 0x51, 0xe0,
0x70, 0x04, 0x04, 0xf0, 0x80, 0x0b, 0xe4, 0x90, 0x04, 0x51, 0xf0, 0x90,
0x04, 0x50, 0xe0, 0x04, 0xf0, 0x90, 0x04, 0x50, 0xe0, 0xc3, 0x64, 0x80,
0x94, 0x86, 0x50, 0x03, 0x02, 0x47, 0x72, 0x80, 0x65, 0x90, 0x04, 0x49,
0xe0, 0x64, 0x01, 0x70, 0x5d, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0,
0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x4a,
0x90, 0x04, 0x50, 0x74, 0x02, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x04, 0x50,
0xe0, 0xff, 0x12, 0x6b, 0x4d, 0xef, 0x60, 0x27, 0x12, 0x6c, 0xf7, 0xe4,
0x90, 0x04, 0x4d, 0xf0, 0x90, 0x04, 0x4b, 0xf0, 0x12, 0x75, 0x3a, 0x90,
0x04, 0x40, 0x74, 0x21, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f,
0x02, 0x22, 0x12, 0x18, 0xe3, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe5, 0x90,
0x04, 0x50, 0xe0, 0x24, 0x02, 0xf0, 0xe0, 0xc3, 0x64, 0x80, 0x94, 0x85,
0x40, 0xbf, 0xe4, 0x90, 0x04, 0x40, 0xf0, 0xff, 0x22, 0xe4, 0xf5, 0x13,
0xf5, 0x14, 0xfd, 0xf5, 0x15, 0xf5, 0x16, 0xf5, 0x12, 0x7f, 0x88, 0x12,
0x78, 0xb8, 0xaa, 0x06, 0xa9, 0x07, 0xea, 0x54, 0x01, 0xf5, 0x14, 0xea,
0xc3, 0x13, 0x54, 0x01, 0xfd, 0xea, 0x13, 0x13, 0x54, 0x01, 0xf5, 0x15,
0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x54, 0xfb, 0xff, 0x90, 0x04,
0x00, 0xee, 0xf0, 0xfe, 0xa3, 0xef, 0xf0, 0x54, 0xf7, 0xff, 0x90, 0x04,
0x00, 0xee, 0xf0, 0xfa, 0xa3, 0xef, 0xf0, 0xfb, 0xaf, 0x05, 0x7e, 0x00,
0xef, 0x54, 0x01, 0x78, 0x07, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8, 0xf9,
0xff, 0xeb, 0x54, 0x7f, 0xfd, 0xea, 0x4e, 0xfe, 0xed, 0x4f, 0xff, 0x90,
0x04, 0x00, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0xe9, 0x14, 0x24, 0xfc, 0x50,
0x2a, 0x60, 0x19, 0x24, 0xfe, 0x60, 0x29, 0x04, 0x24, 0xf8, 0x50, 0x1a,
0x24, 0xdd, 0x60, 0x16, 0x24, 0xfc, 0x24, 0xfd, 0x50, 0x06, 0x60, 0x09,
0x24, 0x38, 0x70, 0x14, 0x75, 0x13, 0x08, 0x80, 0x12, 0x75, 0x13, 0x03,
0x80, 0x0d, 0x75, 0x13, 0x01, 0x80, 0x08, 0x75, 0x13, 0x05, 0x80, 0x03,
0xe4, 0xf5, 0x13, 0xe9, 0x64, 0x1b, 0x60, 0x49, 0xe9, 0x64, 0x17, 0x60,
0x44, 0xe9, 0x64, 0x15, 0x60, 0x3f, 0xe9, 0x64, 0x13, 0x60, 0x3a, 0xe9,
0x64, 0x11, 0x60, 0x35, 0xe9, 0x64, 0x19, 0x60, 0x30, 0xe9, 0x64, 0x1a,
0x60, 0x2b, 0xe9, 0x64, 0x16, 0x60, 0x26, 0xe9, 0x64, 0x14, 0x60, 0x21,
0xe9, 0x64, 0x12, 0x60, 0x1c, 0xe9, 0x64, 0x1c, 0x60, 0x17, 0xe9, 0x64,
0x1e, 0x60, 0x12, 0xe9, 0x64, 0x1f, 0x60, 0x0d, 0xe9, 0x64, 0x21, 0x60,
0x08, 0xe9, 0x64, 0x22, 0x60, 0x03, 0xb9, 0x24, 0x0a, 0x90, 0x04, 0x00,
0xe0, 0xf0, 0xa3, 0xe0, 0x44, 0x04, 0xf0, 0xe5, 0x13, 0xf5, 0xa4, 0x75,
0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x80, 0x75, 0xa5, 0x80, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x80, 0xaf, 0x14, 0xef, 0x25,
0xe0, 0xf5, 0xa4, 0x75, 0xa6, 0xfd, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10,
0xaf, 0x15, 0xef, 0x25, 0xe0, 0xf5, 0xa4, 0x75, 0xa6, 0xfd, 0x75, 0xa7,
0xff, 0xe4, 0xf5, 0x9e, 0x75, 0x9c, 0x96, 0x22, 0x12, 0x78, 0x36, 0x90,
0x04, 0x4f, 0xef, 0xf0, 0xe4, 0x90, 0x04, 0x14, 0xf0, 0xa3, 0xf0, 0x90,
0x04, 0x17, 0xe0, 0x54, 0x08, 0xd3, 0x94, 0x00, 0x40, 0x05, 0xe4, 0xf5,
0xa4, 0x80, 0x03, 0x75, 0xa4, 0x08, 0x75, 0xa6, 0xf7, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x40, 0x90, 0x04, 0x17, 0xe0, 0x54, 0x07, 0xb4, 0x08, 0x00,
0x40, 0x03, 0x02, 0x4a, 0x94, 0x90, 0x49, 0xf8, 0xf8, 0x28, 0x28, 0x73,
0x02, 0x4a, 0x10, 0x02, 0x4a, 0x1f, 0x02, 0x4a, 0x2e, 0x02, 0x4a, 0x49,
0x02, 0x4a, 0x64, 0x02, 0x4a, 0x66, 0x02, 0x4a, 0x6b, 0x02, 0x4a, 0x80,
0x7f, 0x1f, 0x12, 0x73, 0x80, 0x90, 0x04, 0x46, 0xe0, 0xff, 0x12, 0x5f,
0x3c, 0x80, 0x56, 0x7f, 0xe1, 0x12, 0x73, 0x80, 0x90, 0x04, 0x46, 0xe0,
0xff, 0x12, 0x5f, 0x3c, 0x80, 0x5c, 0xe4, 0xff, 0x12, 0x73, 0x80, 0x90,
0x04, 0x49, 0xe0, 0x70, 0x09, 0x7f, 0x20, 0x12, 0x6e, 0xc9, 0x7f, 0xff,
0x80, 0x02, 0x7f, 0xfe, 0x12, 0x6e, 0xc9, 0x80, 0x2c, 0xe4, 0xff, 0x12,
0x73, 0x80, 0x90, 0x04, 0x49, 0xe0, 0x70, 0x09, 0x7f, 0xe0, 0x12, 0x6e,
0xc9, 0x7f, 0x01, 0x80, 0x02, 0x7f, 0x02, 0x12, 0x6e, 0xc9, 0x80, 0x26,
0x80, 0x00, 0x12, 0x4a, 0xef, 0x80, 0x29, 0x7f, 0x20, 0x12, 0x6e, 0x73,
0x7f, 0xff, 0x12, 0x6e, 0x73, 0x90, 0x04, 0x24, 0xe4, 0xf0, 0xa3, 0x74,
0x1f, 0xf0, 0x80, 0x14, 0x7f, 0xe0, 0x12, 0x6e, 0x73, 0x7f, 0x01, 0x12,
0x6e, 0x73, 0x90, 0x04, 0x24, 0x74, 0xff, 0xf0, 0xa3, 0x74, 0xe1, 0xf0,
0x90, 0x04, 0x17, 0xe0, 0x20, 0xe2, 0x34, 0x12, 0x77, 0xc2, 0x90, 0x04,
0x49, 0xe0, 0xd3, 0x94, 0x00, 0x40, 0x25, 0x90, 0x04, 0x17, 0xe0, 0xff,
0x54, 0x02, 0xd3, 0x94, 0x00, 0x40, 0x19, 0xef, 0x54, 0x01, 0xd3, 0x94,
0x01, 0x40, 0x08, 0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x80, 0x06, 0x75,
0xa5, 0x08, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x12, 0x75, 0x3a, 0x12,
0x73, 0x17, 0x7b, 0x01, 0x7a, 0x04, 0x79, 0x54, 0x12, 0x6a, 0xde, 0xe4,
0x90, 0x04, 0x16, 0xf0, 0x90, 0x04, 0x77, 0xf0, 0x90, 0x04, 0x38, 0xf0,
0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x22, 0xe4, 0x90, 0x04, 0x26, 0xf0,
0xa3, 0xf0, 0x7f, 0x44, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e,
0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33, 0x95, 0xe0,
0x12, 0x78, 0xf7, 0x90, 0x04, 0x78, 0xef, 0xf0, 0x7f, 0x43, 0x12, 0x78,
0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12,
0x77, 0xe0, 0x12, 0x78, 0xf7, 0x90, 0x04, 0x79, 0xef, 0xf0, 0xd3, 0x64,
0x80, 0x94, 0x80, 0x40, 0x04, 0xe0, 0xff, 0x80, 0x07, 0x90, 0x04, 0x79,
0xe0, 0xf4, 0x04, 0xff, 0x90, 0x04, 0x78, 0xe0, 0xfe, 0xd3, 0x64, 0x80,
0x94, 0x80, 0x40, 0x02, 0x80, 0x07, 0x90, 0x04, 0x78, 0xe0, 0xf4, 0x04,
0xfe, 0xd3, 0xef, 0x64, 0x80, 0xf8, 0xee, 0x64, 0x80, 0x98, 0x40, 0x07,
0x90, 0x04, 0x27, 0xe0, 0x44, 0x04, 0xf0, 0x90, 0x04, 0x78, 0xe0, 0xd3,
0x64, 0x80, 0x94, 0x80, 0x40, 0x07, 0x90, 0x04, 0x27, 0xe0, 0x44, 0x02,
0xf0, 0x90, 0x04, 0x79, 0xe0, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x07,
0x90, 0x04, 0x27, 0xe0, 0x44, 0x01, 0xf0, 0x90, 0x04, 0x17, 0xe0, 0xc4,
0x54, 0x03, 0x14, 0x60, 0x49, 0x14, 0x60, 0x59, 0x14, 0x60, 0x69, 0x24,
0x03, 0x60, 0x03, 0x02, 0x4c, 0x23, 0x90, 0x04, 0x26, 0xe0, 0xfe, 0xa3,
0xe0, 0xff, 0xc3, 0x94, 0x04, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40, 0x0a,
0xee, 0xa2, 0xe7, 0x13, 0xef, 0x13, 0x7e, 0x00, 0x80, 0x06, 0x7e, 0x00,
0x90, 0x04, 0x27, 0xe0, 0x54, 0x01, 0xff, 0xc3, 0x90, 0x04, 0x27, 0xe0,
0x94, 0x04, 0x90, 0x04, 0x26, 0xe0, 0x64, 0x80, 0x94, 0x80, 0x7d, 0x00,
0x40, 0x02, 0x7d, 0x01, 0x80, 0x42, 0x90, 0x04, 0x17, 0xe0, 0x54, 0x01,
0xd3, 0x94, 0x00, 0x7f, 0x00, 0x40, 0x02, 0x7f, 0x01, 0xe4, 0xfd, 0x80,
0x2f, 0x90, 0x04, 0x17, 0xe0, 0x54, 0x01, 0xd3, 0x94, 0x00, 0x7f, 0x00,
0x40, 0x02, 0x7f, 0x01, 0x7d, 0x01, 0x80, 0x1c, 0x90, 0x04, 0x26, 0xe0,
0xa2, 0xe7, 0x13, 0xa3, 0xe0, 0x13, 0x54, 0x01, 0xff, 0x7d, 0x01, 0x12,
0x58, 0xa6, 0x90, 0x04, 0x26, 0xa3, 0xe0, 0x54, 0x01, 0xff, 0xe4, 0xfd,
0x12, 0x58, 0xa6, 0x22, 0x8f, 0x1d, 0x90, 0x04, 0x24, 0xe4, 0xf0, 0xa3,
0x74, 0x0e, 0xf0, 0xed, 0x70, 0x03, 0x02, 0x4c, 0xc3, 0xe5, 0x1d, 0x60,
0x3a, 0x7f, 0x44, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00,
0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0x12, 0x78, 0xf7, 0x90, 0x04,
0x78, 0xe0, 0xc3, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x50, 0x17,
0x7f, 0x44, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d,
0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x24, 0x01, 0x80, 0x42, 0xe5,
0x1d, 0x60, 0x03, 0x02, 0x4d, 0x4b, 0x7f, 0x44, 0x12, 0x78, 0xeb, 0xef,
0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0,
0x12, 0x78, 0xf7, 0x90, 0x04, 0x78, 0xe0, 0xd3, 0x64, 0x80, 0xf8, 0xef,
0x64, 0x80, 0x98, 0x50, 0x03, 0x02, 0x4d, 0x4b, 0x7f, 0x44, 0x12, 0x78,
0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12,
0x77, 0xe0, 0xef, 0x24, 0xff, 0xff, 0xef, 0xf5, 0xa4, 0x75, 0xa6, 0xc0,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x44, 0x22, 0xe5, 0x1d, 0x60, 0x3a, 0x7f,
0x43, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20,
0x7c, 0x00, 0x12, 0x77, 0xe0, 0x12, 0x78, 0xf7, 0x90, 0x04, 0x79, 0xe0,
0xc3, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x50, 0x17, 0x7f, 0x43,
0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c,
0x00, 0x12, 0x77, 0xe0, 0xef, 0x24, 0x01, 0x80, 0x3c, 0xe5, 0x1d, 0x70,
0x46, 0x7f, 0x43, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00,
0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0x12, 0x78, 0xf7, 0x90, 0x04,
0x79, 0xe0, 0xd3, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x40, 0x23,
0x7f, 0x43, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d,
0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x24, 0xff, 0xff, 0xef, 0xf5,
0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x43, 0x22, 0xe4,
0x90, 0x04, 0x24, 0xf0, 0xa3, 0xf0, 0x22, 0x90, 0x04, 0x40, 0xe0, 0x24,
0xee, 0x60, 0x5d, 0x80, 0x00, 0x90, 0x04, 0x49, 0xe0, 0x60, 0x03, 0x02,
0x4e, 0x37, 0x90, 0x04, 0x87, 0xe0, 0xff, 0xc4, 0x13, 0x13, 0x54, 0x03,
0x30, 0xe0, 0x03, 0x02, 0x4e, 0x37, 0x12, 0x71, 0x32, 0x12, 0x78, 0x36,
0x90, 0x04, 0x4e, 0xef, 0xf0, 0x90, 0x04, 0x46, 0xe0, 0x90, 0x04, 0x52,
0xf0, 0x7f, 0x0f, 0x12, 0x72, 0xab, 0xe4, 0x90, 0x04, 0x4b, 0xf0, 0x90,
0x04, 0x4b, 0xe0, 0xff, 0xc3, 0x94, 0x04, 0x50, 0x4c, 0xa3, 0xe0, 0xb4,
0x01, 0x05, 0x12, 0x5d, 0xe7, 0x80, 0x08, 0x90, 0x04, 0x4b, 0xe0, 0xff,
0x12, 0x68, 0x32, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x40, 0x74, 0x12, 0xf0,
0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0x90, 0x04, 0x4c,
0xe0, 0xb4, 0x01, 0x0b, 0x90, 0x04, 0x4b, 0xe0, 0xff, 0x12, 0x1e, 0xe1,
0xef, 0x80, 0x08, 0x90, 0x04, 0x4b, 0xe0, 0xff, 0x12, 0x27, 0x45, 0x90,
0x04, 0x4d, 0xe0, 0x60, 0xce, 0x90, 0x04, 0x4b, 0xe0, 0x04, 0xf0, 0x80,
0xaa, 0x90, 0x04, 0x52, 0xe0, 0xff, 0x12, 0x5f, 0x3c, 0x90, 0x04, 0x4e,
0xe0, 0xff, 0x12, 0x73, 0x80, 0x12, 0x72, 0x71, 0xef, 0x64, 0x01, 0x70,
0x36, 0x90, 0x04, 0x06, 0xe0, 0xff, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x20,
0xe0, 0x29, 0x7d, 0x01, 0x7f, 0x1b, 0x12, 0x34, 0x1e, 0x90, 0x04, 0x7f,
0xe0, 0xff, 0x13, 0x13, 0x13, 0x54, 0x1f, 0x20, 0xe0, 0x0f, 0x75, 0xa4,
0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x19, 0x7f, 0x01,
0x22, 0x90, 0x04, 0x8b, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x40, 0x74, 0x30,
0xf0, 0x90, 0x04, 0x7d, 0xe0, 0x04, 0xf0, 0x90, 0x04, 0x49, 0xe0, 0x70,
0x33, 0x90, 0x04, 0x00, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xae, 0x04, 0x78,
0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x1d, 0xed,
0xae, 0x04, 0x78, 0x07, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20,
0xe0, 0x0e, 0x90, 0x04, 0x87, 0xe0, 0xff, 0xc4, 0x54, 0x0f, 0x20, 0xe0,
0x03, 0x02, 0x41, 0xa0, 0x7f, 0x00, 0x22, 0x75, 0x20, 0x00, 0x75, 0x21,
0x00, 0x75, 0x22, 0x16, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x12, 0x8b, 0x1d,
0x8a, 0x1e, 0x89, 0x1f, 0xab, 0x20, 0xaa, 0x21, 0xa9, 0x22, 0x12, 0x26,
0x61, 0x78, 0x03, 0x12, 0x26, 0x3b, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x23,
0x12, 0x56, 0x2e, 0x75, 0xf0, 0x02, 0xe5, 0x38, 0xa4, 0x24, 0xf8, 0xf5,
0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83, 0xe4, 0x93, 0xfc, 0x74, 0x01,
0x93, 0xfd, 0x90, 0x04, 0x77, 0xe0, 0xfe, 0xfb, 0x7a, 0x00, 0xed, 0x2b,
0xfd, 0xea, 0x3c, 0xfc, 0x74, 0x00, 0x2d, 0xf5, 0x82, 0x74, 0x01, 0x3c,
0xf5, 0x83, 0xef, 0xf0, 0xee, 0xc3, 0x94, 0xbf, 0x40, 0x06, 0x7e, 0x00,
0x7f, 0xbf, 0x80, 0x07, 0xeb, 0x24, 0x01, 0xff, 0xe4, 0x3a, 0xfe, 0x90,
0x04, 0x77, 0xef, 0xf0, 0xab, 0x1d, 0xaa, 0x1e, 0xa9, 0x1f, 0x12, 0x26,
0x61, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x24, 0x12, 0x56, 0x2e, 0xa9, 0x07,
0xe5, 0x23, 0xc4, 0x54, 0xf0, 0x45, 0x24, 0xff, 0x75, 0xf0, 0x02, 0xe5,
0x38, 0xa4, 0x24, 0xf8, 0xf5, 0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83,
0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd, 0x90, 0x04, 0x77, 0xe0, 0xfe,
0xfb, 0x7a, 0x00, 0xed, 0x2b, 0xfd, 0xea, 0x3c, 0xfc, 0x74, 0x00, 0x2d,
0xf5, 0x82, 0x74, 0x01, 0x3c, 0xf5, 0x83, 0xef, 0xf0, 0xee, 0xc3, 0x94,
0xbf, 0x40, 0x04, 0x7f, 0xbf, 0x80, 0x06, 0xeb, 0x24, 0x01, 0xff, 0xe4,
0x3a, 0x90, 0x04, 0x77, 0xef, 0xf0, 0x75, 0xf0, 0x02, 0xe5, 0x38, 0xa4,
0x24, 0xf8, 0xf5, 0x82, 0xe5, 0xf0, 0x34, 0x7b, 0xf5, 0x83, 0xe4, 0x93,
0xfe, 0x74, 0x01, 0x93, 0xff, 0x90, 0x04, 0x77, 0xe0, 0xfd, 0xfb, 0x7a,
0x00, 0xef, 0x2b, 0xff, 0xea, 0x3e, 0xfe, 0x74, 0x00, 0x2f, 0xf5, 0x82,
0x74, 0x01, 0x3e, 0xf5, 0x83, 0xe9, 0xf0, 0xed, 0xc3, 0x94, 0xbf, 0x40,
0x04, 0x7f, 0xbf, 0x80, 0x04, 0xeb, 0x24, 0x01, 0xff, 0x90, 0x04, 0x77,
0xef, 0xf0, 0x22, 0x90, 0x04, 0x24, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xec,
0xff, 0x8f, 0x18, 0xed, 0xff, 0x8f, 0x17, 0xd3, 0xe5, 0x17, 0x64, 0x80,
0x94, 0x9f, 0x50, 0x1b, 0xc3, 0xe5, 0x17, 0x64, 0x80, 0x94, 0x61, 0x40,
0x12, 0xd3, 0xe5, 0x18, 0x64, 0x80, 0x94, 0x9f, 0x50, 0x09, 0xc3, 0xe5,
0x18, 0x64, 0x80, 0x94, 0x61, 0x50, 0x15, 0x74, 0x80, 0x90, 0x04, 0x14,
0xf0, 0xa3, 0xe5, 0x18, 0xf0, 0x90, 0x04, 0x78, 0xf0, 0xa3, 0xe5, 0x17,
0xf0, 0x7f, 0x01, 0x22, 0x12, 0x78, 0x36, 0x90, 0x04, 0x4f, 0xef, 0xf0,
0xaf, 0x17, 0x12, 0x73, 0x80, 0x12, 0x77, 0xc2, 0x90, 0x04, 0x49, 0xe0,
0x70, 0x08, 0xaf, 0x18, 0xef, 0x33, 0x95, 0xe0, 0x80, 0x77, 0xc3, 0xe5,
0x18, 0x64, 0x80, 0x94, 0x70, 0x50, 0x2a, 0xaf, 0x18, 0xef, 0x33, 0x95,
0xe0, 0xfe, 0xef, 0x24, 0x1f, 0xff, 0xe4, 0x3e, 0xfe, 0xef, 0x25, 0xe0,
0xff, 0xee, 0x33, 0xfe, 0xef, 0x24, 0x02, 0xff, 0xe4, 0x3e, 0x90, 0x04,
0x24, 0xf0, 0xa3, 0xef, 0xf0, 0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x80,
0x32, 0xd3, 0xe5, 0x18, 0x64, 0x80, 0x94, 0x8f, 0x40, 0x2e, 0xaf, 0x18,
0xef, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0x24, 0xe1, 0xff, 0xee, 0x34, 0xff,
0xfe, 0xef, 0x25, 0xe0, 0xff, 0xee, 0x33, 0xfe, 0xef, 0x24, 0x02, 0xff,
0xe4, 0x3e, 0x90, 0x04, 0x24, 0xf0, 0xa3, 0xef, 0xf0, 0x75, 0xa5, 0x08,
0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x80, 0x14, 0xaf, 0x18, 0xef, 0x33,
0x95, 0xe0, 0xfe, 0xef, 0x25, 0xe0, 0xff, 0xee, 0x33, 0x90, 0x04, 0x24,
0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x04, 0x24, 0xa3, 0xe0, 0xff, 0x12, 0x6e,
0xc9, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x16, 0x12, 0x6a, 0xde, 0x12, 0x73,
0x17, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x14, 0xe4, 0xf0, 0xa3, 0x04, 0xf0,
0x90, 0x04, 0x78, 0xe5, 0x18, 0xf0, 0xa3, 0xe5, 0x17, 0xf0, 0x7f, 0x00,
0x22, 0xe4, 0xfd, 0xf5, 0x13, 0xf5, 0x14, 0x90, 0x04, 0x00, 0xe0, 0xfe,
0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20,
0xe0, 0x03, 0x02, 0x51, 0x75, 0x90, 0x04, 0x4e, 0xe0, 0xff, 0xd3, 0x64,
0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x07, 0x90, 0x04, 0x4e, 0xe0, 0xf4,
0x04, 0xff, 0xc3, 0xef, 0x64, 0x80, 0x94, 0x88, 0x50, 0x08, 0xe4, 0xfd,
0x90, 0x04, 0x58, 0xf0, 0x80, 0x73, 0x90, 0x04, 0x4e, 0xe0, 0xff, 0xd3,
0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x07, 0x90, 0x04, 0x4e, 0xe0,
0xf4, 0x04, 0xff, 0xc3, 0xef, 0x64, 0x80, 0x94, 0x90, 0x50, 0x0a, 0x7d,
0x10, 0x90, 0x04, 0x58, 0x74, 0x04, 0xf0, 0x80, 0x4c, 0x90, 0x04, 0x4e,
0xe0, 0xff, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x07, 0x90,
0x04, 0x4e, 0xe0, 0xf4, 0x04, 0xff, 0xc3, 0xef, 0x64, 0x80, 0x94, 0x98,
0x50, 0x0a, 0x7d, 0x20, 0x90, 0x04, 0x58, 0x74, 0x08, 0xf0, 0x80, 0x25,
0x90, 0x04, 0x4e, 0xe0, 0xff, 0xd3, 0x64, 0x80, 0x94, 0x80, 0x40, 0x02,
0x80, 0x07, 0x90, 0x04, 0x4e, 0xe0, 0xf4, 0x04, 0xff, 0xc3, 0xef, 0x64,
0x80, 0x94, 0xa0, 0x50, 0x08, 0x7d, 0x30, 0x90, 0x04, 0x58, 0x74, 0x0c,
0xf0, 0x7f, 0x01, 0x12, 0x2e, 0x0a, 0x90, 0x04, 0x58, 0xe0, 0xf5, 0xa4,
0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x41, 0x90, 0x04, 0x4e,
0xe0, 0xc3, 0x64, 0x80, 0x94, 0x80, 0x50, 0x06, 0x7e, 0x3f, 0x7f, 0xff,
0x80, 0x04, 0x7e, 0xc0, 0x7f, 0x00, 0x8e, 0x13, 0x8f, 0x14, 0xef, 0x25,
0xe0, 0xf5, 0xa4, 0xe5, 0x14, 0x25, 0xe0, 0xe5, 0x13, 0x33, 0xf5, 0xa5,
0x75, 0xa6, 0x01, 0x75, 0x9a, 0x02, 0x75, 0xa4, 0x80, 0x75, 0xa6, 0x7f,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x01, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0x7f,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x01, 0x7f, 0x00, 0x22, 0x75, 0x15, 0xe1,
0x75, 0x16, 0x1f, 0x75, 0x14, 0xff, 0x7f, 0x38, 0x12, 0x78, 0xb8, 0x8e,
0x12, 0x8f, 0x13, 0xd3, 0xe5, 0x13, 0x94, 0x1f, 0xe5, 0x12, 0x64, 0x80,
0x94, 0x80, 0x40, 0x08, 0x75, 0x12, 0x7f, 0x75, 0x13, 0xff, 0x80, 0x2c,
0xc3, 0xe5, 0x13, 0x94, 0xe0, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x7f, 0x50,
0x08, 0x74, 0xff, 0xf5, 0x12, 0xf5, 0x13, 0x80, 0x17, 0x7f, 0x39, 0x12,
0x78, 0xb8, 0xee, 0x54, 0x03, 0xfc, 0xad, 0x07, 0xe5, 0x13, 0x25, 0xe0,
0x25, 0xe0, 0x4c, 0xf5, 0x12, 0xed, 0xf5, 0x13, 0x90, 0x04, 0x46, 0xe0,
0xf5, 0x17, 0x90, 0x04, 0x4e, 0xe0, 0xfb, 0x90, 0x04, 0x1e, 0xe0, 0xf5,
0x20, 0xa3, 0xe0, 0xf5, 0x21, 0x85, 0x15, 0x22, 0x85, 0x16, 0x23, 0x85,
0x14, 0x24, 0xad, 0x13, 0xac, 0x12, 0xaf, 0x17, 0x12, 0x55, 0x56, 0x8f,
0x18, 0x90, 0x04, 0x62, 0xe0, 0x60, 0x4b, 0xef, 0x33, 0x95, 0xe0, 0xfe,
0xef, 0xc4, 0xf8, 0x54, 0x0f, 0xc8, 0x68, 0xff, 0xee, 0xc4, 0x54, 0xf0,
0x48, 0x90, 0x04, 0x32, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x04, 0x4e, 0xe0,
0xfb, 0x90, 0x04, 0x1e, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0x85,
0x15, 0x22, 0x85, 0x16, 0x23, 0x85, 0x18, 0x24, 0xad, 0x13, 0xac, 0x12,
0xaf, 0x17, 0x12, 0x43, 0x1d, 0xef, 0x33, 0x95, 0xe0, 0xfe, 0x90, 0x04,
0x33, 0xe0, 0x2f, 0xf0, 0x90, 0x04, 0x32, 0xe0, 0x3e, 0xf0, 0x90, 0x04,
0x4e, 0xe5, 0x17, 0xf0, 0x90, 0x04, 0x1e, 0xe5, 0x12, 0xf0, 0xa3, 0xe5,
0x13, 0xf0, 0x90, 0x04, 0x62, 0xe0, 0x90, 0x04, 0x4d, 0xf0, 0xaf, 0x18,
0x02, 0x5f, 0x3c, 0x90, 0x04, 0x14, 0xe0, 0xa3, 0x30, 0xe7, 0x03, 0x02,
0x53, 0x8f, 0x75, 0xa4, 0x20, 0x75, 0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0x11, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x12, 0x12, 0x57, 0x08, 0x75,
0x1a, 0x00, 0x8f, 0x1b, 0xe5, 0x1b, 0x64, 0x01, 0x45, 0x1a, 0x60, 0x03,
0x02, 0x53, 0x82, 0x12, 0x6b, 0xb9, 0x90, 0x04, 0x11, 0x74, 0x01, 0xf0,
0x90, 0x04, 0x49, 0xe0, 0x70, 0x0d, 0x90, 0x04, 0x18, 0xf0, 0xa3, 0xf0,
0xa3, 0xf0, 0xa3, 0xf0, 0x02, 0x53, 0x75, 0x90, 0x04, 0x78, 0xe0, 0xff,
0xc3, 0x64, 0x80, 0x94, 0x70, 0x40, 0x24, 0xd3, 0xef, 0x64, 0x80, 0x94,
0x8f, 0x50, 0x1c, 0x7f, 0x34, 0x12, 0x78, 0xb8, 0xee, 0x33, 0x95, 0xe0,
0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xc0, 0x04, 0xc0, 0x05, 0xc0,
0x06, 0xc0, 0x07, 0x7f, 0x35, 0x80, 0x1a, 0x7f, 0x36, 0x12, 0x78, 0xb8,
0xee, 0x33, 0x95, 0xe0, 0xfd, 0xfc, 0x78, 0x0a, 0x12, 0x26, 0x4e, 0xc0,
0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x37, 0x12, 0x78, 0xeb,
0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xeb, 0x4f, 0xf5, 0x19,
0xea, 0xf5, 0x18, 0xe9, 0xf5, 0x17, 0xe8, 0xf5, 0x16, 0xaf, 0x19, 0xae,
0x18, 0xad, 0x17, 0xfc, 0x78, 0x10, 0x12, 0x26, 0x3b, 0x90, 0x04, 0x18,
0xee, 0xf0, 0xa3, 0xef, 0xf0, 0xe5, 0x19, 0xff, 0xe5, 0x18, 0xfe, 0xa3,
0xee, 0xf0, 0xa3, 0xef, 0xf0, 0xe5, 0x1a, 0x44, 0xec, 0x90, 0x04, 0x14,
0xf0, 0xe5, 0x1b, 0xa3, 0xf0, 0x22, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xdf,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x11, 0x22, 0x22, 0x75, 0x15, 0xe1, 0x75,
0x16, 0x1f, 0x90, 0x04, 0x63, 0xe0, 0xff, 0x90, 0x04, 0x67, 0xe0, 0xc3,
0x9f, 0xf5, 0x12, 0xd3, 0x64, 0x80, 0x94, 0x78, 0x50, 0x05, 0x75, 0x13,
0x01, 0x80, 0x11, 0xc3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x88, 0x40, 0x05,
0x75, 0x13, 0xff, 0x80, 0x03, 0xe4, 0xf5, 0x13, 0x7f, 0x46, 0x12, 0x78,
0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12,
0x77, 0xe0, 0xe5, 0x13, 0x2f, 0xf5, 0x14, 0xc3, 0xe5, 0x15, 0x64, 0x80,
0xf8, 0xe5, 0x14, 0x64, 0x80, 0x98, 0x50, 0x03, 0x85, 0x15, 0x14, 0xd3,
0xe5, 0x16, 0x64, 0x80, 0xf8, 0xe5, 0x14, 0x64, 0x80, 0x98, 0x40, 0x03,
0x85, 0x16, 0x14, 0x90, 0x04, 0x64, 0xe0, 0xff, 0x90, 0x04, 0x68, 0xe0,
0xc3, 0x9f, 0xf5, 0x12, 0xd3, 0x64, 0x80, 0x94, 0x78, 0x50, 0x05, 0x75,
0x13, 0x01, 0x80, 0x11, 0xc3, 0xe5, 0x12, 0x64, 0x80, 0x94, 0x88, 0x40,
0x05, 0x75, 0x13, 0xff, 0x80, 0x03, 0xe4, 0xf5, 0x13, 0x7f, 0x45, 0x12,
0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00,
0x12, 0x77, 0xe0, 0xe5, 0x13, 0x2f, 0xff, 0xc3, 0xe5, 0x15, 0x64, 0x80,
0xf8, 0xef, 0x64, 0x80, 0x98, 0x50, 0x02, 0xaf, 0x15, 0xd3, 0xe5, 0x16,
0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x40, 0x02, 0xaf, 0x16, 0xef,
0x54, 0x3f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x45, 0xaf, 0x14, 0xef, 0x54, 0x3f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x46, 0x22, 0x7f, 0x41, 0x12, 0x78, 0xeb, 0xef,
0x54, 0x0f, 0xff, 0x90, 0x04, 0x58, 0xf0, 0x90, 0x04, 0x22, 0xe4, 0xf0,
0xa3, 0xef, 0xf0, 0x90, 0x04, 0x28, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xd3,
0x94, 0x00, 0xee, 0x64, 0x80, 0x94, 0x80, 0x40, 0x02, 0x80, 0x0f, 0x90,
0x04, 0x28, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xc3, 0xe4, 0x9f, 0xff, 0xe4,
0x9e, 0xfe, 0xd3, 0xef, 0x94, 0x04, 0xee, 0x64, 0x80, 0x94, 0x80, 0x50,
0x08, 0x90, 0x04, 0x4c, 0xe0, 0x64, 0x01, 0x60, 0x58, 0x90, 0x04, 0x58,
0xe0, 0xff, 0x90, 0x04, 0x28, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x90, 0x04,
0x5a, 0xe0, 0xfe, 0xfb, 0x90, 0x04, 0x2a, 0xe0, 0xf5, 0x20, 0xa3, 0xe0,
0xf5, 0x21, 0xe4, 0xf5, 0x22, 0x75, 0x23, 0x0f, 0x12, 0x55, 0x53, 0x90,
0x04, 0x58, 0xef, 0xf0, 0x90, 0x04, 0x22, 0xa3, 0xe0, 0x90, 0x04, 0x5a,
0xf0, 0x90, 0x04, 0x62, 0xe0, 0xb4, 0x01, 0x16, 0x90, 0x04, 0x5a, 0xe0,
0xff, 0x90, 0x04, 0x58, 0xe0, 0x90, 0x04, 0x5c, 0xb5, 0x07, 0x02, 0x80,
0x18, 0x74, 0x02, 0xf0, 0x80, 0x16, 0xe4, 0x90, 0x04, 0x5c, 0xf0, 0x80,
0x0f, 0x90, 0x04, 0x22, 0xa3, 0xe0, 0x90, 0x04, 0x5a, 0xf0, 0x90, 0x04,
0x5c, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x28, 0xe0, 0xff, 0xa3, 0xe0, 0xa3,
0xcf, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x04, 0x4c, 0xe0, 0xb4, 0x01, 0x0b,
0x90, 0x04, 0x5c, 0xe0, 0x64, 0x01, 0x60, 0x03, 0x74, 0x02, 0xf0, 0x90,
0x04, 0x58, 0xe0, 0xf5, 0xa4, 0x75, 0xa6, 0xf0, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0x41, 0x22, 0x75, 0x24, 0xff, 0x8f, 0x1c, 0x8c, 0x1d, 0x8d, 0x1e,
0x8b, 0x1f, 0xe4, 0xf5, 0x26, 0xf5, 0x27, 0xe5, 0x1e, 0x45, 0x1d, 0x70,
0x0a, 0x85, 0x1c, 0x25, 0x90, 0x04, 0x62, 0x04, 0xf0, 0x80, 0x75, 0xc3,
0xe5, 0x1d, 0x64, 0x80, 0x94, 0x80, 0x50, 0x0c, 0xe5, 0x21, 0x94, 0x00,
0xe5, 0x20, 0x64, 0x80, 0x94, 0x80, 0x50, 0x15, 0xd3, 0xe5, 0x1e, 0x94,
0x00, 0xe5, 0x1d, 0x64, 0x80, 0x94, 0x80, 0x40, 0x35, 0xe5, 0x20, 0x64,
0x80, 0x94, 0x80, 0x50, 0x2d, 0xaf, 0x21, 0xae, 0x20, 0x12, 0x78, 0x49,
0xc0, 0x06, 0xc0, 0x07, 0xaf, 0x1e, 0xae, 0x1d, 0x12, 0x78, 0x49, 0xd0,
0x05, 0xd0, 0x04, 0xc3, 0xef, 0x9d, 0xee, 0x9c, 0x50, 0x05, 0x85, 0x1c,
0x25, 0x80, 0x03, 0x85, 0x1f, 0x25, 0x90, 0x04, 0x62, 0x74, 0x01, 0xf0,
0x80, 0x1e, 0xc3, 0xe5, 0x1d, 0x64, 0x80, 0x94, 0x80, 0x7f, 0xff, 0x40,
0x02, 0x7f, 0x01, 0xef, 0x85, 0x24, 0xf0, 0xa4, 0xff, 0xc3, 0xe5, 0x1c,
0x9f, 0xf5, 0x25, 0xe4, 0x90, 0x04, 0x62, 0xf0, 0xd3, 0xe5, 0x23, 0x64,
0x80, 0xf8, 0xe5, 0x25, 0x64, 0x80, 0x98, 0x40, 0x05, 0x85, 0x23, 0x25,
0x80, 0x10, 0xc3, 0xe5, 0x22, 0x64, 0x80, 0xf8, 0xe5, 0x25, 0x64, 0x80,
0x98, 0x50, 0x0c, 0x85, 0x22, 0x25, 0x75, 0x26, 0x01, 0x90, 0x04, 0x62,
0x74, 0x01, 0xf0, 0xe5, 0x25, 0x65, 0x23, 0x60, 0x05, 0xe5, 0x25, 0xb5,
0x22, 0x03, 0x75, 0x27, 0x01, 0x90, 0x04, 0x60, 0xe5, 0x26, 0xf0, 0xa3,
0xe5, 0x27, 0xf0, 0xaf, 0x25, 0x22, 0x8f, 0x28, 0x8e, 0x27, 0x8d, 0x26,
0x8c, 0x25, 0x8b, 0x29, 0x8a, 0x2a, 0x89, 0x2b, 0xe4, 0xff, 0xfe, 0xfd,
0xfc, 0xab, 0x28, 0xaa, 0x27, 0xa9, 0x26, 0xa8, 0x25, 0xc3, 0x12, 0x26,
0x2a, 0x70, 0x0b, 0xab, 0x29, 0xaa, 0x2a, 0xa9, 0x2b, 0x12, 0x25, 0xf0,
0xff, 0x22, 0xe4, 0xf5, 0x2c, 0x7f, 0xff, 0x7e, 0xff, 0x7d, 0x7f, 0xfc,
0xab, 0x28, 0xaa, 0x27, 0xa9, 0x26, 0xa8, 0x25, 0xd3, 0x12, 0x26, 0x2a,
0x40, 0x0c, 0x75, 0x28, 0xff, 0x75, 0x27, 0xff, 0x75, 0x26, 0x7f, 0x75,
0x25, 0x00, 0xaf, 0x28, 0xae, 0x27, 0xad, 0x26, 0xac, 0x25, 0x78, 0x01,
0x12, 0x26, 0x4e, 0x8f, 0x28, 0x8e, 0x27, 0x8d, 0x26, 0x8c, 0x25, 0x05,
0x2c, 0xe4, 0xff, 0xfe, 0xfd, 0xe5, 0x25, 0x54, 0x80, 0xfc, 0xe4, 0xfb,
0xfa, 0xf9, 0xf8, 0xc3, 0x12, 0x26, 0x2a, 0x60, 0xd5, 0xe5, 0x2c, 0x75,
0xf0, 0x20, 0x12, 0x25, 0x93, 0xaf, 0xf0, 0xc3, 0x74, 0x1f, 0x9f, 0xab,
0x29, 0xaa, 0x2a, 0xa9, 0x2b, 0x12, 0x25, 0xf0, 0xab, 0x29, 0xaa, 0x2a,
0xa9, 0x2b, 0x12, 0x25, 0xb5, 0xfb, 0xc3, 0x94, 0x08, 0x50, 0x1d, 0xe4,
0xff, 0xfe, 0xfd, 0xe5, 0x25, 0xfc, 0xeb, 0xf4, 0x04, 0x24, 0x1f, 0xf9,
0xf8, 0x12, 0x26, 0x3b, 0x8f, 0x2d, 0xab, 0x29, 0xa9, 0x2b, 0xe4, 0x12,
0x25, 0xf0, 0x80, 0x19, 0xe4, 0xff, 0xfe, 0xfd, 0xe5, 0x25, 0xfc, 0x78,
0x18, 0x12, 0x26, 0x3b, 0x8f, 0x2d, 0xab, 0x29, 0xaa, 0x2a, 0xa9, 0x2b,
0x74, 0xf9, 0x12, 0x25, 0xce, 0xaf, 0x2d, 0x22, 0x8b, 0x1d, 0x8a, 0x1e,
0x89, 0x1f, 0x12, 0x71, 0x76, 0x8f, 0x23, 0x8e, 0x22, 0x8d, 0x21, 0x8c,
0x20, 0x90, 0x04, 0x20, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xe4, 0xfc, 0xfd,
0x78, 0x10, 0x12, 0x26, 0x4e, 0xa8, 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xab,
0x07, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xeb, 0x4f, 0xfb, 0xea, 0x4e,
0xfa, 0xc3, 0xe5, 0x23, 0x9b, 0xff, 0xe5, 0x22, 0x9a, 0xfe, 0xe5, 0x21,
0x99, 0xfd, 0xe5, 0x20, 0x98, 0xfc, 0xab, 0x1d, 0xaa, 0x1e, 0xa9, 0x1f,
0x12, 0x26, 0x81, 0x90, 0x04, 0x34, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xe4,
0xfc, 0xfd, 0x78, 0x10, 0x12, 0x26, 0x4e, 0xa8, 0x04, 0xa9, 0x05, 0xaa,
0x06, 0xab, 0x07, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xeb, 0x4f, 0xfb,
0xea, 0x4e, 0xfa, 0xc3, 0xe5, 0x23, 0x9b, 0xf5, 0x27, 0xe5, 0x22, 0x9a,
0xf5, 0x26, 0xe5, 0x21, 0x99, 0xf5, 0x25, 0xe5, 0x20, 0x98, 0xf5, 0x24,
0x90, 0x04, 0x11, 0xe0, 0xb4, 0x05, 0x1f, 0x90, 0x00, 0x61, 0xe0, 0xff,
0xe4, 0xfc, 0xfd, 0xfe, 0x78, 0x07, 0x12, 0x26, 0x4e, 0xab, 0x27, 0xaa,
0x26, 0xa9, 0x25, 0xa8, 0x24, 0xd3, 0x12, 0x26, 0x2a, 0x40, 0x22, 0x7f,
0x01, 0x22, 0x90, 0x00, 0x61, 0xe0, 0xff, 0xe4, 0xfc, 0xfd, 0xfe, 0x78,
0x11, 0x12, 0x26, 0x4e, 0xab, 0x27, 0xaa, 0x26, 0xa9, 0x25, 0xa8, 0x24,
0xd3, 0x12, 0x26, 0x2a, 0x40, 0x03, 0x7f, 0x01, 0x22, 0x7f, 0x00, 0x22,
0xef, 0x12, 0x26, 0x9b, 0x58, 0x52, 0x00, 0x58, 0x98, 0x01, 0x58, 0x9c,
0x02, 0x58, 0xa0, 0x03, 0x58, 0x90, 0x04, 0x58, 0x52, 0x05, 0x58, 0x94,
0x06, 0x58, 0x78, 0x08, 0x58, 0x84, 0x09, 0x58, 0x88, 0x0a, 0x58, 0x74,
0x0b, 0x58, 0x70, 0x0c, 0x58, 0x6c, 0x0d, 0x58, 0x68, 0x0e, 0x58, 0x62,
0x0f, 0x58, 0x60, 0x10, 0x58, 0x5e, 0x11, 0x58, 0x7c, 0x12, 0x58, 0x80,
0x13, 0x58, 0x5a, 0x14, 0x58, 0x58, 0x15, 0x58, 0x56, 0x16, 0x58, 0x54,
0x17, 0x58, 0x52, 0x19, 0x58, 0x52, 0x1a, 0x58, 0x52, 0x1b, 0x58, 0x52,
0x1c, 0x58, 0x64, 0x1d, 0x58, 0x52, 0x1e, 0x58, 0x52, 0x1f, 0x58, 0x5c,
0x20, 0x58, 0x52, 0x21, 0x58, 0x52, 0x22, 0x58, 0x52, 0x24, 0x58, 0x52,
0x35, 0x58, 0x52, 0x36, 0x58, 0x52, 0x37, 0x58, 0x52, 0x38, 0x00, 0x00,
0x58, 0x52, 0x80, 0x38, 0x80, 0x1e, 0x80, 0x1c, 0x80, 0x22, 0x80, 0x20,
0x80, 0x06, 0x80, 0x08, 0x80, 0x06, 0x80, 0x04, 0x7f, 0x07, 0x80, 0x3a,
0x7f, 0x01, 0x80, 0x36, 0x7f, 0x05, 0x80, 0x32, 0x7f, 0x04, 0x80, 0x2e,
0x7f, 0x03, 0x80, 0x2a, 0x7f, 0x01, 0x80, 0x26, 0x7f, 0x02, 0x80, 0x22,
0x7f, 0x02, 0x80, 0x1e, 0x7f, 0x01, 0x80, 0x1a, 0x7f, 0x01, 0x80, 0x16,
0x7f, 0x06, 0x80, 0x12, 0x7f, 0x01, 0x80, 0x0e, 0x7f, 0x01, 0x80, 0x0a,
0x7f, 0x01, 0x80, 0x06, 0x7f, 0x01, 0x80, 0x02, 0x7f, 0x01, 0x12, 0x2b,
0xdd, 0x22, 0x8f, 0x16, 0xed, 0x60, 0x4f, 0xe5, 0x16, 0x60, 0x27, 0x7f,
0xf1, 0x12, 0x78, 0xf8, 0xef, 0x33, 0x95, 0xe0, 0xef, 0xf5, 0xa4, 0x75,
0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x44, 0x90, 0x04, 0x17, 0xe0,
0xc4, 0x54, 0x03, 0x64, 0x03, 0x70, 0x03, 0x02, 0x59, 0x70, 0x7f, 0x44,
0x80, 0x3f, 0x7f, 0x0f, 0x12, 0x78, 0xf8, 0xef, 0x33, 0x95, 0xe0, 0xef,
0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x44, 0x90,
0x04, 0x17, 0xe0, 0xc4, 0x54, 0x03, 0x64, 0x03, 0x60, 0x7a, 0x7f, 0x44,
0x80, 0x53, 0xe5, 0x16, 0x60, 0x38, 0x7f, 0xf1, 0x12, 0x78, 0xf8, 0xef,
0x33, 0x95, 0xe0, 0xef, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x43, 0x7f, 0x43, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff,
0x7e, 0x00, 0x7d, 0x20, 0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33, 0x95,
0xe0, 0xfe, 0xc3, 0x74, 0xf1, 0x9f, 0x90, 0x04, 0x25, 0xf0, 0x74, 0xff,
0x80, 0x35, 0x7f, 0x0f, 0x12, 0x78, 0xf8, 0xef, 0x33, 0x95, 0xe0, 0xef,
0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x43, 0x7f,
0x43, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff, 0x7e, 0x00, 0x7d, 0x20,
0x7c, 0x00, 0x12, 0x77, 0xe0, 0xef, 0x33, 0x95, 0xe0, 0xfe, 0xc3, 0x74,
0x0f, 0x9f, 0x90, 0x04, 0x25, 0xf0, 0xe4, 0x9e, 0x90, 0x04, 0x24, 0xf0,
0x22, 0x12, 0x71, 0x32, 0xe4, 0x90, 0x04, 0x2e, 0xf0, 0xa3, 0xf0, 0xa3,
0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x83, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x86,
0xf0, 0x90, 0x04, 0x3e, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3,
0xf0, 0x90, 0x04, 0x8a, 0xf0, 0x90, 0x04, 0x44, 0xf0, 0xa3, 0x74, 0x20,
0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x04, 0x6d, 0xf0, 0x90, 0x04, 0x7b, 0xf0,
0xa3, 0xf0, 0x90, 0x04, 0x7e, 0xf0, 0x90, 0x04, 0x4a, 0xf0, 0x90, 0x04,
0x4c, 0xf0, 0x90, 0x04, 0x5a, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x82, 0xf0,
0x90, 0x04, 0x55, 0xf0, 0x90, 0x04, 0x28, 0xf0, 0xa3, 0xf0, 0x90, 0x04,
0x5c, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x2a, 0xf0, 0xa3, 0xf0,
0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x5f, 0xf0, 0x90, 0x04, 0x6a, 0xf0,
0x90, 0x04, 0x69, 0xf0, 0x90, 0x04, 0x6b, 0xf0, 0xa3, 0xf0, 0x90, 0x04,
0x6f, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x12, 0xf0,
0xa3, 0xf0, 0x90, 0x04, 0x0d, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0,
0x90, 0x04, 0x73, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0x04,
0x6e, 0xf0, 0x90, 0x04, 0x7d, 0xf0, 0x90, 0x04, 0x32, 0xf0, 0xa3, 0xf0,
0x90, 0x04, 0x8b, 0xf0, 0x90, 0x04, 0x14, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0,
0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x22, 0xab,
0x07, 0xaa, 0x06, 0x90, 0x00, 0x5c, 0xe0, 0xff, 0x12, 0x75, 0x0d, 0x8f,
0x19, 0xe4, 0xf5, 0x15, 0xf5, 0x16, 0x8a, 0x17, 0x8b, 0x18, 0x12, 0x72,
0x37, 0xad, 0x07, 0xed, 0xd3, 0x95, 0x19, 0x50, 0x2d, 0x90, 0x04, 0x6b,
0xe0, 0xc3, 0x95, 0x19, 0x50, 0x24, 0xae, 0x17, 0xaf, 0x18, 0xee, 0xc4,
0xf8, 0x54, 0xf0, 0xc8, 0xef, 0xc4, 0x54, 0x0f, 0x48, 0x54, 0x03, 0x64,
0x03, 0x60, 0x0f, 0xae, 0x15, 0xaf, 0x16, 0xef, 0x54, 0xcf, 0x8e, 0x15,
0x44, 0x10, 0xf5, 0x16, 0x80, 0x54, 0xed, 0xd3, 0x95, 0x19, 0x40, 0x48,
0x90, 0x04, 0x6b, 0xe0, 0xff, 0x95, 0x19, 0x50, 0x3f, 0xed, 0x2f, 0xfb,
0xe4, 0x33, 0xfa, 0xe5, 0x19, 0x25, 0xe0, 0xff, 0xe4, 0x33, 0xfe, 0xd3,
0xeb, 0x9f, 0xee, 0x64, 0x80, 0xf8, 0xea, 0x64, 0x80, 0x98, 0x40, 0x24,
0xae, 0x17, 0xaf, 0x18, 0xee, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0xef, 0xc4,
0x54, 0x0f, 0x48, 0x54, 0x03, 0x64, 0x02, 0x60, 0x0f, 0xae, 0x15, 0xaf,
0x16, 0xef, 0x54, 0xcf, 0x8e, 0x15, 0x44, 0x20, 0xf5, 0x16, 0x80, 0x00,
0x90, 0x04, 0x69, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x6b, 0xed, 0xf0, 0xae,
0x15, 0xaf, 0x16, 0xee, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0xef, 0xc4, 0x54,
0x0f, 0x48, 0x54, 0x03, 0x60, 0x07, 0xaf, 0x16, 0xae, 0x15, 0x12, 0x76,
0xac, 0x90, 0x04, 0x69, 0xe0, 0xff, 0x22, 0x75, 0x15, 0xc1, 0x75, 0x16,
0x3f, 0x75, 0x14, 0xff, 0x90, 0x04, 0x49, 0xe0, 0x70, 0x04, 0x7f, 0x38,
0x80, 0x0d, 0x90, 0x04, 0x49, 0xe0, 0xb4, 0x01, 0x04, 0x7f, 0x36, 0x80,
0x02, 0x7f, 0x38, 0x12, 0x78, 0xb8, 0x8e, 0x12, 0x8f, 0x13, 0x7f, 0x49,
0x12, 0x78, 0xeb, 0xef, 0x54, 0x7f, 0xff, 0x7e, 0x00, 0x7d, 0x40, 0x7c,
0x00, 0x12, 0x77, 0xe0, 0x8f, 0x17, 0x90, 0x04, 0x4e, 0xe0, 0xfb, 0x90,
0x04, 0x1e, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0x85, 0x15, 0x22,
0x85, 0x16, 0x23, 0x85, 0x14, 0x24, 0xad, 0x13, 0xac, 0x12, 0x12, 0x55,
0x56, 0xa9, 0x07, 0x90, 0x04, 0x4e, 0xe5, 0x17, 0xf0, 0x90, 0x04, 0x1e,
0xe5, 0x12, 0xf0, 0xa3, 0xe5, 0x13, 0xf0, 0x90, 0x04, 0x62, 0xe0, 0x90,
0x04, 0x4d, 0xf0, 0x64, 0x01, 0x70, 0x1e, 0x90, 0x04, 0x60, 0xe0, 0xfb,
0x7a, 0x00, 0x7d, 0x06, 0x7f, 0x40, 0x7e, 0x00, 0x12, 0x70, 0xa8, 0x90,
0x04, 0x61, 0xe0, 0xfb, 0x7d, 0x06, 0x7f, 0x40, 0x7e, 0x00, 0x12, 0x71,
0xbb, 0xe9, 0xff, 0xef, 0xf5, 0xa4, 0x75, 0xa6, 0x80, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x49, 0xd3, 0xe9, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xaf,
0x01, 0x80, 0x04, 0xe9, 0xf4, 0x04, 0xff, 0xc3, 0xef, 0x64, 0x80, 0x94,
0xbf, 0x90, 0x04, 0x3d, 0xe0, 0x40, 0x04, 0x44, 0x02, 0xf0, 0x22, 0x54,
0xfd, 0xf0, 0x22, 0xe4, 0xf5, 0x12, 0x90, 0x04, 0x7f, 0xe0, 0x30, 0xe0,
0x03, 0x02, 0x5c, 0x7a, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xf9, 0x60, 0x0c,
0x14, 0x60, 0x12, 0x80, 0x00, 0xe4, 0x90, 0x04, 0x4e, 0xf0, 0xa3, 0xf0,
0x12, 0x73, 0x4c, 0x90, 0x04, 0x40, 0x74, 0x08, 0xf0, 0x12, 0x78, 0xac,
0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0x12, 0x77, 0x62, 0x8f, 0x12, 0xe5,
0x12, 0x60, 0x73, 0x90, 0x04, 0x4e, 0xe0, 0x25, 0x12, 0xf0, 0xa3, 0xe0,
0x04, 0xf0, 0x90, 0x04, 0x4e, 0xe0, 0xff, 0xc3, 0x64, 0x80, 0x94, 0xa0,
0x7e, 0x00, 0x50, 0x02, 0x7e, 0x01, 0xd3, 0xee, 0x64, 0x80, 0x94, 0x80,
0x40, 0x0d, 0xef, 0x64, 0x80, 0x94, 0xa0, 0x7f, 0x00, 0x50, 0x02, 0x7f,
0x01, 0x80, 0x13, 0x90, 0x04, 0x4e, 0xe0, 0xc3, 0x64, 0x80, 0x94, 0xa0,
0x7f, 0x00, 0x50, 0x02, 0x7f, 0x01, 0xef, 0xf4, 0x04, 0xff, 0xef, 0x60,
0x17, 0x90, 0x04, 0x4f, 0xe0, 0xc3, 0x64, 0x80, 0x94, 0xb0, 0x50, 0x0c,
0x12, 0x50, 0xad, 0x90, 0x04, 0x40, 0x74, 0x07, 0xf0, 0x7f, 0x02, 0x22,
0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x19,
0x7d, 0x01, 0x7f, 0x17, 0x12, 0x34, 0x1e, 0x7f, 0x01, 0x22, 0xe4, 0x90,
0x04, 0x4e, 0xf0, 0xa3, 0xf0, 0xff, 0x22, 0x8f, 0x1f, 0xe5, 0x2c, 0x64,
0x01, 0x70, 0x69, 0xaf, 0x23, 0xae, 0x22, 0xad, 0x21, 0xac, 0x20, 0xec,
0x4d, 0x4e, 0x4f, 0x70, 0x0a, 0x85, 0x1f, 0x2d, 0x90, 0x04, 0x62, 0x04,
0xf0, 0x80, 0x6c, 0xec, 0x33, 0x50, 0x12, 0xe4, 0xff, 0xfe, 0xfd, 0xfc,
0xab, 0x28, 0xaa, 0x27, 0xa9, 0x26, 0xa8, 0x25, 0x12, 0x26, 0x14, 0x50,
0x19, 0xe4, 0xff, 0xfe, 0xfd, 0xfc, 0xab, 0x23, 0xaa, 0x22, 0xa9, 0x21,
0xa8, 0x20, 0xd3, 0x12, 0x26, 0x14, 0x40, 0x1c, 0xac, 0x25, 0xec, 0x33,
0x50, 0x16, 0xac, 0x20, 0xec, 0x33, 0x50, 0x05, 0x85, 0x1f, 0x2d, 0x80,
0x03, 0x85, 0x24, 0x2d, 0x90, 0x04, 0x62, 0x74, 0x01, 0xf0, 0x80, 0x27,
0xac, 0x20, 0xec, 0x33, 0x7f, 0xff, 0x40, 0x02, 0x7f, 0x01, 0x80, 0x0a,
0xac, 0x20, 0xec, 0x33, 0x7f, 0xff, 0x40, 0x02, 0x7f, 0x01, 0xef, 0x85,
0x2b, 0xf0, 0xa4, 0xff, 0xc3, 0xe5, 0x1f, 0x9f, 0xf5, 0x2d, 0xe4, 0x90,
0x04, 0x62, 0xf0, 0xd3, 0xe5, 0x2a, 0x64, 0x80, 0xf8, 0xe5, 0x2d, 0x64,
0x80, 0x98, 0x40, 0x05, 0x85, 0x2a, 0x2d, 0x80, 0x10, 0xc3, 0xe5, 0x29,
0x64, 0x80, 0xf8, 0xe5, 0x2d, 0x64, 0x80, 0x98, 0x50, 0x09, 0x85, 0x29,
0x2d, 0x90, 0x04, 0x62, 0x74, 0x01, 0xf0, 0xaf, 0x2d, 0x22, 0x90, 0x00,
0x52, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x4e, 0x60, 0x02, 0x80, 0x03, 0x12,
0x78, 0x6b, 0xac, 0x06, 0xad, 0x07, 0x90, 0x00, 0x56, 0xe0, 0xfe, 0xa3,
0xe0, 0x78, 0x03, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0xff, 0xc3,
0xed, 0x9f, 0xff, 0xec, 0x9e, 0xfe, 0x90, 0x00, 0x57, 0xe0, 0x2f, 0xf0,
0x90, 0x00, 0x56, 0xe0, 0x3e, 0xf0, 0xe4, 0x90, 0x00, 0x63, 0xf0, 0x90,
0x00, 0x5c, 0xe0, 0xff, 0xd3, 0x94, 0x00, 0x40, 0x2b, 0xef, 0x25, 0xe0,
0x24, 0xfa, 0xf5, 0x82, 0xe4, 0x34, 0x7a, 0xf5, 0x83, 0x74, 0x01, 0x93,
0x24, 0x50, 0xff, 0xe4, 0x93, 0x34, 0x00, 0xfe, 0xd3, 0x90, 0x00, 0x57,
0xe0, 0x9f, 0x90, 0x00, 0x56, 0xe0, 0x9e, 0x40, 0x07, 0x90, 0x00, 0x5c,
0xe0, 0x14, 0x80, 0x33, 0x90, 0x00, 0x5c, 0xe0, 0xff, 0xc3, 0x94, 0x14,
0x50, 0x30, 0xef, 0x25, 0xe0, 0x24, 0xfa, 0xf5, 0x82, 0xe4, 0x34, 0x7a,
0xf5, 0x83, 0x74, 0x01, 0x93, 0x24, 0xb0, 0xff, 0xe4, 0x93, 0x34, 0xff,
0xfe, 0xc3, 0x90, 0x00, 0x57, 0xe0, 0x9f, 0x90, 0x00, 0x56, 0xe0, 0x9e,
0x50, 0x0c, 0x90, 0x00, 0x5c, 0xe0, 0x04, 0xf0, 0x90, 0x00, 0x63, 0x74,
0x01, 0xf0, 0x22, 0xad, 0x07, 0xe4, 0x90, 0x04, 0x4d, 0xf0, 0xed, 0x70,
0x17, 0x90, 0x04, 0x0f, 0xe0, 0x13, 0x13, 0x13, 0x54, 0x1f, 0x90, 0x04,
0x51, 0xf0, 0x90, 0x04, 0x0f, 0xe0, 0xfe, 0x90, 0x04, 0x75, 0x80, 0x1a,
0xbd, 0x01, 0x28, 0x90, 0x04, 0x10, 0xe0, 0x13, 0x13, 0x13, 0x54, 0x1f,
0xf4, 0x04, 0x90, 0x04, 0x51, 0xf0, 0x90, 0x04, 0x10, 0xe0, 0xfe, 0x90,
0x04, 0x76, 0xe0, 0x7a, 0x00, 0x24, 0x00, 0xff, 0xea, 0x3e, 0x90, 0x04,
0x22, 0xf0, 0xa3, 0xef, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0x04, 0x51, 0xf0,
0xbd, 0x02, 0x19, 0x90, 0x04, 0x0d, 0xe0, 0x13, 0x13, 0x13, 0x54, 0x1f,
0xf4, 0x04, 0x90, 0x04, 0x50, 0xf0, 0x90, 0x04, 0x0d, 0xe0, 0xfe, 0x90,
0x04, 0x73, 0x80, 0x18, 0xbd, 0x03, 0x26, 0x90, 0x04, 0x0e, 0xe0, 0x13,
0x13, 0x13, 0x54, 0x1f, 0x90, 0x04, 0x50, 0xf0, 0x90, 0x04, 0x0e, 0xe0,
0xfe, 0x90, 0x04, 0x74, 0xe0, 0x7c, 0x00, 0x24, 0x00, 0xff, 0xec, 0x3e,
0x90, 0x04, 0x22, 0xf0, 0xa3, 0xef, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0x04,
0x50, 0xf0, 0x90, 0x04, 0x51, 0xe0, 0xff, 0x12, 0x73, 0x80, 0x90, 0x04,
0x50, 0xe0, 0xff, 0x02, 0x5f, 0x3c, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xfd,
0x70, 0x03, 0x02, 0x5f, 0x1f, 0x14, 0x60, 0x29, 0x14, 0x60, 0x4d, 0x80,
0x00, 0x7f, 0x01, 0x12, 0x78, 0x23, 0x75, 0xa4, 0x10, 0x75, 0xa6, 0xef,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x40, 0x7f, 0xff, 0x12, 0x71, 0x2f, 0x7f,
0x09, 0x12, 0x75, 0x8f, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x40, 0x74, 0x04,
0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0x7f, 0xff,
0x12, 0x15, 0xc3, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe3, 0xe4, 0xff, 0x12,
0x71, 0x2f, 0x7f, 0x09, 0x12, 0x75, 0xb9, 0x12, 0x75, 0x3a, 0x90, 0x04,
0x40, 0x74, 0x05, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02,
0x22, 0xe4, 0xff, 0x12, 0x15, 0xc3, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe3,
0xe4, 0xff, 0x12, 0x73, 0x80, 0x7f, 0x01, 0x12, 0x6c, 0x8e, 0x12, 0x71,
0x32, 0x7f, 0x09, 0x12, 0x75, 0x65, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x40,
0x74, 0x03, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22,
0x7f, 0x01, 0x12, 0x15, 0xc3, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe3, 0x12,
0x53, 0x90, 0xe4, 0xff, 0x12, 0x78, 0x23, 0x22, 0x8f, 0x1f, 0x7f, 0x0a,
0x12, 0x78, 0xb8, 0xee, 0xff, 0xe5, 0x1f, 0x2f, 0xff, 0x90, 0x04, 0x6d,
0xe0, 0x2f, 0x25, 0xe0, 0xa2, 0xe7, 0x13, 0xff, 0x75, 0xa5, 0x20, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0x8f, 0x75, 0x9a, 0x04, 0xef, 0x30, 0xe7, 0x12,
0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfb, 0x75, 0x9a, 0x04,
0xef, 0xf4, 0x04, 0xff, 0x80, 0x0c, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0xfb, 0x75, 0x9a, 0x04, 0x90, 0x04, 0x44, 0xe0, 0x60, 0x28,
0x75, 0xa4, 0x01, 0x75, 0xa6, 0x80, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x04,
0xe4, 0xfe, 0xc3, 0xef, 0x64, 0x80, 0xf8, 0xee, 0x64, 0x80, 0x98, 0x50,
0x3b, 0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a,
0x04, 0x0e, 0x80, 0xe6, 0xef, 0xfd, 0xed, 0x54, 0x7f, 0xf5, 0xa4, 0x74,
0x08, 0xf5, 0xa5, 0x75, 0xa6, 0x80, 0x75, 0xa7, 0xf7, 0x75, 0x9a, 0x04,
0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a, 0x04,
0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xf7, 0x75, 0x9a, 0x04,
0x90, 0x04, 0x46, 0xe5, 0x1f, 0xf0, 0x22, 0x90, 0x04, 0x40, 0xe0, 0x24,
0xef, 0x60, 0x4b, 0x80, 0x00, 0x90, 0x04, 0x49, 0xe0, 0x60, 0x03, 0x02,
0x60, 0x7b, 0x90, 0x04, 0x00, 0xe0, 0xc4, 0xf8, 0x54, 0xf0, 0xc8, 0xa3,
0xe0, 0xc4, 0x54, 0x0f, 0x48, 0x54, 0x03, 0x64, 0x02, 0x60, 0x70, 0x12,
0x71, 0x32, 0x7f, 0x0c, 0x12, 0x76, 0x85, 0xe4, 0x90, 0x04, 0x24, 0xf0,
0xa3, 0xf0, 0x90, 0x04, 0x4b, 0x74, 0x06, 0xf0, 0x90, 0x04, 0x4b, 0xe0,
0xff, 0xc3, 0x94, 0x16, 0x50, 0x4c, 0x12, 0x6f, 0x1f, 0x12, 0x75, 0x3a,
0x90, 0x04, 0x40, 0x74, 0x11, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03,
0x7f, 0x02, 0x22, 0x7f, 0x38, 0x12, 0x78, 0xb8, 0xef, 0x4e, 0x60, 0x26,
0x7f, 0x38, 0x12, 0x78, 0xb8, 0xd3, 0xef, 0x94, 0x00, 0xee, 0x64, 0x80,
0x94, 0x80, 0x40, 0x06, 0x7e, 0x00, 0x7f, 0x01, 0x80, 0x04, 0x7e, 0xff,
0x7f, 0xff, 0x90, 0x04, 0x25, 0xe0, 0x2f, 0xf0, 0x90, 0x04, 0x24, 0xe0,
0x3e, 0xf0, 0x90, 0x04, 0x4b, 0xe0, 0x04, 0xf0, 0x80, 0xaa, 0x12, 0x69,
0x8d, 0x80, 0x06, 0x90, 0x04, 0x5d, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x40,
0x74, 0x31, 0xf0, 0x7f, 0x00, 0x22, 0x90, 0x04, 0x43, 0xe0, 0x24, 0xd3,
0x60, 0x53, 0x14, 0x60, 0x1f, 0x80, 0x00, 0x90, 0x04, 0x57, 0xe0, 0x90,
0x04, 0x8c, 0xf0, 0x7f, 0x14, 0x12, 0x74, 0x4c, 0xe4, 0x90, 0x04, 0x1e,
0xf0, 0xa3, 0xf0, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x43, 0x74, 0x2e, 0xf0,
0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0xe4, 0xff, 0x12,
0x64, 0xce, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe3, 0x90, 0x04, 0x57, 0xe0,
0x90, 0x04, 0x53, 0xf0, 0x7f, 0x14, 0x12, 0x74, 0x7f, 0xe4, 0x90, 0x04,
0x1e, 0xf0, 0xa3, 0xf0, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x43, 0x74, 0x2d,
0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0xe4, 0xff,
0x12, 0x64, 0xce, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe3, 0xe4, 0x90, 0x04,
0x43, 0xf0, 0x90, 0x04, 0x57, 0xe0, 0xff, 0xfd, 0x33, 0x95, 0xe0, 0xfc,
0x90, 0x04, 0x53, 0xe0, 0xfe, 0xd3, 0x9d, 0xec, 0x64, 0x80, 0xf8, 0x74,
0x80, 0x98, 0x50, 0x04, 0xaf, 0x06, 0x80, 0x00, 0x90, 0x04, 0x53, 0xef,
0xf0, 0x90, 0x04, 0x8c, 0xe0, 0xff, 0x12, 0x73, 0x80, 0x7f, 0x00, 0x22,
0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x1f, 0xff, 0x7e, 0x00, 0xc0,
0x06, 0xc0, 0x07, 0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x3f, 0x13,
0x13, 0x13, 0x54, 0x1f, 0xfd, 0xd0, 0xe0, 0x2d, 0xf5, 0x15, 0xd0, 0xe0,
0x34, 0x00, 0xf5, 0x14, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x7f,
0xc4, 0x13, 0x13, 0x54, 0x03, 0x64, 0x01, 0x70, 0x0a, 0xc3, 0x95, 0x15,
0xff, 0xe4, 0x95, 0x14, 0xfe, 0x80, 0x04, 0xae, 0x14, 0xaf, 0x15, 0x8e,
0x12, 0x8f, 0x13, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x1f, 0xff,
0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3c, 0x12, 0x78, 0xe6, 0xef,
0x54, 0x07, 0xfd, 0xd0, 0xe0, 0x2d, 0xf5, 0x17, 0xd0, 0xe0, 0x34, 0x00,
0xf5, 0x16, 0x7f, 0x3c, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xc4, 0x13,
0x54, 0x07, 0x64, 0x01, 0x70, 0x0a, 0xc3, 0x95, 0x17, 0xff, 0xe4, 0x95,
0x16, 0xfe, 0x80, 0x04, 0xae, 0x16, 0xaf, 0x17, 0xe5, 0x13, 0x2f, 0xff,
0xe5, 0x12, 0x3e, 0xa2, 0xe7, 0x13, 0xfe, 0xef, 0x13, 0x24, 0xef, 0xff,
0xee, 0x34, 0xff, 0xfe, 0x22, 0x7e, 0x00, 0x7f, 0x40, 0x7d, 0x00, 0x7b,
0x01, 0x7a, 0x00, 0x79, 0x50, 0x12, 0x26, 0xc1, 0xe4, 0x90, 0x00, 0x50,
0xf0, 0xa3, 0xf0, 0x90, 0x00, 0x50, 0xe4, 0xf0, 0xa3, 0x74, 0x26, 0xf0,
0xe4, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0x74, 0xd1, 0xf0, 0xa3, 0x74, 0x0f,
0xf0, 0x90, 0x00, 0x5e, 0x74, 0x13, 0xf0, 0x90, 0x00, 0x5c, 0x74, 0x0b,
0xf0, 0xe4, 0x90, 0x00, 0x63, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0,
0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0x04, 0xf0, 0x12,
0x78, 0x6b, 0xef, 0x78, 0x03, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8, 0xf9,
0xff, 0x90, 0x00, 0x56, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0xf5, 0x09,
0x12, 0x5d, 0x3a, 0x05, 0x09, 0xe5, 0x09, 0xc3, 0x94, 0x08, 0x40, 0xf4,
0xe4, 0x90, 0x00, 0x5f, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0x5d, 0x04, 0xf0,
0xe4, 0x90, 0x00, 0x58, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x7e,
0x02, 0x7f, 0xf8, 0xfd, 0x7b, 0x01, 0x7a, 0x01, 0x79, 0x00, 0x12, 0x26,
0xc1, 0xe4, 0xf5, 0x33, 0xf5, 0x34, 0xf5, 0x35, 0x22, 0x90, 0x04, 0x42,
0xe0, 0x24, 0xe3, 0x60, 0x41, 0x14, 0x60, 0x74, 0x80, 0x00, 0x90, 0x04,
0x49, 0xe0, 0x60, 0x03, 0x02, 0x63, 0x02, 0x90, 0x04, 0x00, 0xe0, 0xfe,
0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x30,
0xe0, 0x6c, 0x90, 0x04, 0x88, 0xe0, 0xff, 0x13, 0x13, 0x13, 0x54, 0x1f,
0x20, 0xe0, 0x29, 0x12, 0x71, 0x32, 0x7d, 0x10, 0x7f, 0x04, 0x12, 0x6c,
0xfe, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x42, 0x74, 0x1d, 0xf0, 0x12, 0x78,
0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0x7d, 0x01, 0x7f, 0x05, 0x12,
0x18, 0xeb, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe1, 0x90, 0x04, 0x88, 0xe0,
0xff, 0x13, 0x13, 0x13, 0x54, 0x1f, 0x20, 0xe0, 0x29, 0x12, 0x71, 0x32,
0x7d, 0x10, 0x7f, 0x05, 0x12, 0x6c, 0xfe, 0x12, 0x75, 0x3a, 0x90, 0x04,
0x42, 0x74, 0x1e, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02,
0x22, 0x7d, 0x01, 0x7f, 0x04, 0x12, 0x18, 0xeb, 0x90, 0x04, 0x4d, 0xe0,
0x60, 0xe1, 0xe4, 0x90, 0x04, 0x42, 0xf0, 0xff, 0x22, 0x8f, 0x1c, 0x7f,
0x0a, 0x12, 0x78, 0xeb, 0xe5, 0x1c, 0x2f, 0x25, 0xe0, 0xa2, 0xe7, 0x13,
0xff, 0x75, 0xa5, 0x40, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x8f, 0x75, 0x9a,
0x04, 0xef, 0x30, 0xe7, 0x12, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xfb, 0x75, 0x9a, 0x04, 0xef, 0xf4, 0x04, 0xff, 0x80, 0x0c, 0x75,
0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfb, 0x75, 0x9a, 0x04, 0x90,
0x04, 0x44, 0xe0, 0x60, 0x28, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0x80, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x04, 0xe4, 0xfe, 0xc3, 0xef, 0x64, 0x80, 0xf8,
0xee, 0x64, 0x80, 0x98, 0x50, 0x3c, 0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0xfd, 0x75, 0x9a, 0x04, 0x0e, 0x80, 0xe6, 0xef, 0xfd, 0xed,
0x54, 0x7f, 0xf5, 0xa4, 0x74, 0x08, 0xf5, 0xa5, 0x75, 0xa6, 0x80, 0x75,
0xa7, 0xf7, 0x75, 0x9a, 0x04, 0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xfd, 0x75, 0x9a, 0x04, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0xf7, 0x75, 0x9a, 0x04, 0x22, 0x22, 0xef, 0x25, 0xe0, 0x25, 0xe0,
0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x83, 0x75, 0x9a, 0x14, 0xe4,
0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x21, 0xe4,
0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x23, 0xe4,
0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x25, 0xe4,
0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x27, 0xe4,
0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x29, 0x90,
0x04, 0x88, 0xe0, 0x20, 0xe0, 0x0c, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff,
0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x21, 0x90, 0x04, 0x88, 0xe0, 0xc3, 0x13,
0x20, 0xe0, 0x0c, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f,
0x75, 0x9a, 0x23, 0x90, 0x04, 0x88, 0xe0, 0x13, 0x13, 0x54, 0x3f, 0x20,
0xe0, 0x0c, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75,
0x9a, 0x25, 0x75, 0xa4, 0x40, 0x75, 0xa6, 0xbf, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0x10, 0x22, 0x8f, 0x16, 0x8e, 0x15, 0x8d, 0x14, 0x8c, 0x13, 0xe4,
0xff, 0xfe, 0xfd, 0xfc, 0xab, 0x16, 0xaa, 0x15, 0xa9, 0x14, 0xa8, 0x13,
0xc3, 0x12, 0x26, 0x2a, 0x70, 0x02, 0xff, 0x22, 0xe4, 0x7f, 0x01, 0xfe,
0xfd, 0xfc, 0xab, 0x16, 0xaa, 0x15, 0xa9, 0x14, 0xa8, 0x13, 0xc3, 0x12,
0x26, 0x2a, 0x70, 0x03, 0x7f, 0xe0, 0x22, 0xe4, 0xf5, 0x17, 0xe5, 0x16,
0xf5, 0x16, 0xe5, 0x15, 0xf5, 0x15, 0xe5, 0x14, 0xf5, 0x14, 0xe5, 0x13,
0x54, 0x7f, 0xf5, 0x13, 0xaf, 0x16, 0xae, 0x15, 0xad, 0x14, 0xac, 0x13,
0x78, 0x01, 0x12, 0x26, 0x4e, 0x8f, 0x16, 0x8e, 0x15, 0x8d, 0x14, 0x8c,
0x13, 0x05, 0x17, 0xe4, 0xff, 0xfe, 0xfd, 0xe5, 0x13, 0x54, 0x80, 0xfc,
0xe4, 0xfb, 0xfa, 0xf9, 0xf8, 0xc3, 0x12, 0x26, 0x2a, 0x60, 0xd5, 0xe4,
0xff, 0xfe, 0xfd, 0xe5, 0x13, 0x54, 0x70, 0xfc, 0x78, 0x17, 0x12, 0x26,
0x3b, 0xe5, 0x17, 0x75, 0xf0, 0x20, 0x12, 0x25, 0x93, 0xae, 0xf0, 0xc3,
0x74, 0x1f, 0x9e, 0x2f, 0xff, 0x22, 0x8f, 0x14, 0x90, 0x04, 0x49, 0xe0,
0xb4, 0x01, 0x04, 0x7f, 0x34, 0x80, 0x02, 0x7f, 0x38, 0x12, 0x78, 0xb8,
0x7c, 0x00, 0xef, 0x25, 0x14, 0xff, 0xec, 0x3e, 0x90, 0x04, 0x1c, 0xf0,
0xa3, 0xef, 0xf0, 0x90, 0x04, 0x57, 0xe0, 0xfe, 0x33, 0x95, 0xe0, 0x90,
0x04, 0x26, 0xf0, 0xa3, 0xce, 0xf0, 0xff, 0x90, 0x04, 0x1c, 0xe0, 0xfc,
0xa3, 0xe0, 0xfd, 0x90, 0x04, 0x4e, 0xe0, 0xfb, 0x90, 0x04, 0x1e, 0xe0,
0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0xe4, 0xf5, 0x22, 0x75, 0x23, 0x1f,
0x12, 0x55, 0x53, 0x90, 0x04, 0x57, 0xef, 0xf0, 0x90, 0x04, 0x26, 0xa3,
0xe0, 0x90, 0x04, 0x4e, 0xf0, 0x90, 0x04, 0x62, 0xe0, 0x90, 0x04, 0x4d,
0xf0, 0x90, 0x04, 0x1c, 0xe0, 0xff, 0xa3, 0xe0, 0xa3, 0xcf, 0xf0, 0xa3,
0xef, 0xf0, 0x90, 0x04, 0x57, 0xe0, 0xff, 0x12, 0x73, 0x80, 0x90, 0x04,
0x60, 0xe0, 0x60, 0x07, 0x90, 0x04, 0x82, 0x74, 0x01, 0xf0, 0x22, 0xe4,
0x90, 0x04, 0x82, 0xf0, 0x22, 0x90, 0x04, 0x49, 0xe0, 0xff, 0x60, 0x19,
0xb4, 0x01, 0x13, 0x90, 0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02,
0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x20, 0xe0, 0x03, 0x7f, 0x00,
0x22, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xf1, 0x60, 0x38, 0x80, 0x00, 0x90,
0x04, 0x87, 0xe0, 0xff, 0xc4, 0x13, 0x54, 0x07, 0x20, 0xe0, 0x3e, 0x12,
0x71, 0x32, 0xe4, 0xff, 0x12, 0x5f, 0x3c, 0x7f, 0x09, 0x12, 0x73, 0xe6,
0x75, 0xa4, 0x20, 0x75, 0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x30,
0x12, 0x78, 0x36, 0x90, 0x04, 0x57, 0xef, 0xf0, 0x12, 0x75, 0x3a, 0x90,
0x04, 0x40, 0x74, 0x0f, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f,
0x02, 0x22, 0x7f, 0x3c, 0x12, 0x64, 0xce, 0x90, 0x04, 0x4d, 0xe0, 0x60,
0xe3, 0x90, 0x04, 0x40, 0x74, 0x32, 0xf0, 0x7f, 0x00, 0x22, 0x90, 0x04,
0x40, 0xe0, 0x24, 0xf4, 0x60, 0x39, 0x80, 0x00, 0x12, 0x71, 0x32, 0x90,
0x04, 0x46, 0xe0, 0x90, 0x04, 0x4f, 0xf0, 0x12, 0x78, 0x36, 0x90, 0x04,
0x50, 0xef, 0xf0, 0xe4, 0xff, 0x12, 0x5f, 0x3c, 0xe4, 0xff, 0x12, 0x73,
0x80, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x03, 0x7f, 0x09, 0x12, 0x73, 0xb3, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x40,
0x74, 0x0c, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22,
0x12, 0x51, 0xbd, 0x90, 0x04, 0x4d, 0xe0, 0x70, 0x09, 0x90, 0x04, 0x4b,
0xe0, 0xc3, 0x94, 0x20, 0x40, 0xdc, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xfe,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x03, 0x90, 0x04, 0x4f, 0xe0, 0xff, 0x12,
0x5f, 0x3c, 0x90, 0x04, 0x50, 0xe0, 0xff, 0x12, 0x73, 0x80, 0x7f, 0x00,
0x22, 0xe4, 0xf5, 0x15, 0xf5, 0x16, 0x8e, 0x17, 0x8f, 0x18, 0x90, 0x00,
0x5c, 0xe0, 0xff, 0x12, 0x74, 0xe0, 0x90, 0x04, 0x56, 0xe0, 0xc3, 0x9f,
0x50, 0x45, 0x90, 0x04, 0x6c, 0xe0, 0xff, 0x64, 0x80, 0x94, 0x80, 0x40,
0x02, 0x80, 0x07, 0x90, 0x04, 0x6c, 0xe0, 0xf4, 0x04, 0xff, 0xc3, 0xef,
0x64, 0x80, 0x94, 0x81, 0x50, 0x29, 0xae, 0x17, 0xaf, 0x18, 0xef, 0x78,
0x02, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0x54, 0x03, 0x64, 0x02,
0x60, 0x15, 0xae, 0x15, 0xaf, 0x16, 0xef, 0x54, 0xf3, 0x8e, 0x15, 0x44,
0x08, 0xf5, 0x16, 0x90, 0x04, 0x6c, 0xe0, 0x14, 0xf0, 0x80, 0x06, 0x90,
0x04, 0x6a, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x6a, 0xe0, 0x64, 0x01, 0x60,
0x07, 0xaf, 0x16, 0xae, 0x15, 0x12, 0x76, 0xac, 0x90, 0x04, 0x6a, 0xe0,
0xff, 0x22, 0x7e, 0x00, 0x7f, 0x80, 0x7d, 0x00, 0x7b, 0x01, 0x7a, 0x04,
0x79, 0x00, 0x12, 0x26, 0xc1, 0x7e, 0x00, 0x7f, 0x20, 0x7d, 0x00, 0x7b,
0x01, 0x7a, 0x04, 0x79, 0x80, 0x12, 0x26, 0xc1, 0xe4, 0x90, 0x04, 0x00,
0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x3c, 0x74, 0x02, 0xf0, 0xe4, 0xa3, 0xf0,
0x90, 0x04, 0x0b, 0xf0, 0x90, 0x04, 0x0a, 0xf0, 0x90, 0x04, 0x0c, 0xf0,
0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x10, 0xf0, 0x90, 0x04, 0x0f, 0xf0,
0x90, 0x04, 0x12, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x11, 0xf0, 0x90, 0x04,
0x48, 0xf0, 0x90, 0x04, 0x04, 0xf0, 0x90, 0x04, 0x03, 0xf0, 0x90, 0x04,
0x06, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x05, 0x74,
0x02, 0xf0, 0x90, 0x04, 0x02, 0x14, 0xf0, 0xe4, 0x90, 0x04, 0x7f, 0xf0,
0x02, 0x59, 0x71, 0x90, 0xe0, 0x06, 0xe0, 0xff, 0xe4, 0x8f, 0x19, 0xf5,
0x18, 0xf5, 0x17, 0xf5, 0x16, 0xa3, 0xe0, 0xff, 0xe4, 0xfc, 0xfd, 0xfe,
0x78, 0x08, 0x12, 0x26, 0x4e, 0xe5, 0x19, 0x4f, 0xf5, 0x19, 0xe5, 0x18,
0x4e, 0xf5, 0x18, 0xe5, 0x17, 0x4d, 0xf5, 0x17, 0xe5, 0x16, 0x4c, 0xf5,
0x16, 0xa3, 0xe0, 0xff, 0xe4, 0xfc, 0xfd, 0xfe, 0x78, 0x10, 0x12, 0x26,
0x4e, 0xe5, 0x19, 0x4f, 0xf5, 0x19, 0xe5, 0x18, 0x4e, 0xf5, 0x18, 0xe5,
0x17, 0x4d, 0xf5, 0x17, 0xe5, 0x16, 0x4c, 0xf5, 0x16, 0xa3, 0xe0, 0xff,
0xe4, 0xfc, 0xfd, 0xfe, 0x78, 0x18, 0x12, 0x26, 0x4e, 0xe5, 0x19, 0x4f,
0xf5, 0x19, 0xe5, 0x18, 0x4e, 0xf5, 0x18, 0xe5, 0x17, 0x4d, 0xf5, 0x17,
0xe5, 0x16, 0x4c, 0xf5, 0x16, 0xaf, 0x19, 0xae, 0x18, 0xad, 0x17, 0xfc,
0x22, 0x90, 0x04, 0x49, 0xe0, 0xb4, 0x01, 0x04, 0x7f, 0x34, 0x80, 0x02,
0x7f, 0x38, 0x12, 0x78, 0xb8, 0x90, 0x04, 0x1c, 0xee, 0xf0, 0xa3, 0xef,
0xf0, 0x90, 0x04, 0x56, 0xe0, 0xff, 0x90, 0x04, 0x22, 0xe4, 0xf0, 0xa3,
0xef, 0xf0, 0x90, 0x04, 0x1c, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x90, 0x04,
0x4e, 0xe0, 0xfb, 0x90, 0x04, 0x1e, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5,
0x21, 0xa3, 0xa3, 0xe0, 0xf5, 0x22, 0x75, 0x23, 0x2d, 0x75, 0x24, 0x01,
0x12, 0x55, 0x56, 0x90, 0x04, 0x56, 0xef, 0xf0, 0x90, 0x04, 0x22, 0xa3,
0xe0, 0x90, 0x04, 0x4e, 0xf0, 0x90, 0x04, 0x62, 0xe0, 0x90, 0x04, 0x4d,
0xf0, 0x90, 0x04, 0x1c, 0xe0, 0xff, 0xa3, 0xe0, 0xa3, 0xcf, 0xf0, 0xa3,
0xef, 0xf0, 0x90, 0x04, 0x56, 0xe0, 0xff, 0x02, 0x78, 0xf3, 0xe4, 0x90,
0x04, 0x4d, 0xf0, 0x90, 0x04, 0x53, 0xf0, 0x90, 0x04, 0x62, 0xf0, 0x90,
0x04, 0x1c, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xef, 0x70, 0x09,
0x75, 0x12, 0x0f, 0x90, 0x04, 0x75, 0xf0, 0x80, 0x10, 0xbf, 0x01, 0x0a,
0x75, 0x12, 0xf0, 0xe4, 0x90, 0x04, 0x76, 0xf0, 0x80, 0x03, 0xe4, 0xf5,
0x12, 0xbf, 0x02, 0x05, 0x75, 0x13, 0xf0, 0x80, 0x0e, 0xbf, 0x03, 0x05,
0x75, 0x13, 0x0f, 0x80, 0x06, 0x90, 0x04, 0x46, 0xe0, 0xf5, 0x13, 0xef,
0x64, 0x02, 0x60, 0x03, 0xbf, 0x03, 0x08, 0x90, 0x04, 0x4f, 0xe5, 0x13,
0xf0, 0x80, 0x06, 0x90, 0x04, 0x4f, 0xe5, 0x12, 0xf0, 0xe4, 0x90, 0x04,
0x51, 0xf0, 0x90, 0x04, 0x4f, 0xe0, 0xa3, 0xf0, 0xaf, 0x12, 0x12, 0x73,
0x80, 0xaf, 0x13, 0x02, 0x5f, 0x3c, 0xe4, 0xfd, 0xfc, 0xfb, 0x90, 0x00,
0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x54, 0x1f, 0xc3, 0x94, 0x05,
0xe4, 0x94, 0x00, 0x50, 0x05, 0x7d, 0x04, 0x7c, 0x04, 0x0b, 0xeb, 0x54,
0x01, 0xf5, 0xa4, 0x75, 0xa6, 0xfe, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0xb0,
0xec, 0x54, 0x02, 0xc3, 0x13, 0x25, 0xe0, 0x54, 0x02, 0xff, 0xec, 0x54,
0x04, 0x13, 0x13, 0x54, 0x3f, 0x25, 0xe0, 0x25, 0xe0, 0x54, 0x04, 0x4f,
0xff, 0xec, 0x54, 0x01, 0x4f, 0xff, 0xed, 0x54, 0x04, 0x13, 0x13, 0x54,
0x3f, 0xc4, 0x33, 0x54, 0x20, 0x4f, 0xff, 0xed, 0x54, 0x02, 0xc3, 0x13,
0xc4, 0x54, 0x10, 0x4f, 0xff, 0xed, 0x54, 0x01, 0x33, 0x33, 0x33, 0x54,
0x08, 0x4f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0xb3, 0x22, 0xe4, 0xf5, 0x15, 0x12, 0x78, 0x36, 0xef, 0x33, 0x95, 0xe0,
0xf5, 0x13, 0x8f, 0x14, 0xc3, 0x64, 0x80, 0x94, 0x80, 0x50, 0x0e, 0xc3,
0xe4, 0x95, 0x14, 0xf5, 0x14, 0xe4, 0x95, 0x13, 0xf5, 0x13, 0x75, 0x15,
0x01, 0x7f, 0x40, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x0f, 0x13, 0x13, 0x13,
0x54, 0x1f, 0x60, 0x12, 0xe5, 0x14, 0x25, 0xe0, 0xff, 0xe5, 0x13, 0x33,
0xfe, 0x74, 0x64, 0x2f, 0xf5, 0x82, 0x74, 0x7b, 0x80, 0x10, 0xe5, 0x14,
0x25, 0xe0, 0xff, 0xe5, 0x13, 0x33, 0xfe, 0x74, 0x24, 0x2f, 0xf5, 0x82,
0x74, 0x7b, 0x3e, 0xf5, 0x83, 0xe4, 0x93, 0xf5, 0x16, 0x74, 0x01, 0x93,
0xf5, 0x17, 0xe5, 0x15, 0x60, 0x0a, 0xc3, 0xe4, 0x95, 0x17, 0xff, 0xe4,
0x95, 0x16, 0xfe, 0x22, 0xae, 0x16, 0xaf, 0x17, 0x22, 0x7f, 0x42, 0x12,
0x78, 0xeb, 0xef, 0x54, 0x07, 0xff, 0x90, 0x04, 0x59, 0xf0, 0x90, 0x04,
0x22, 0xe4, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x04, 0x59, 0xe0, 0xff, 0x90,
0x04, 0x24, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x90, 0x04, 0x5b, 0xe0, 0xfe,
0xfb, 0x90, 0x04, 0x2c, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0xe4,
0xf5, 0x22, 0x75, 0x23, 0x07, 0x75, 0x24, 0xff, 0x12, 0x55, 0x56, 0x90,
0x04, 0x59, 0xef, 0xf0, 0x90, 0x04, 0x22, 0xa3, 0xe0, 0x90, 0x04, 0x5b,
0xf0, 0x90, 0x04, 0x62, 0xe0, 0x90, 0x04, 0x5d, 0xf0, 0x90, 0x04, 0x24,
0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x04, 0x2c, 0xcf, 0xf0, 0xa3, 0xef, 0xf0,
0x90, 0x04, 0x59, 0xe0, 0xf5, 0xa4, 0x75, 0xa6, 0xf8, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x42, 0x22, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xe9, 0x60, 0x3b,
0x14, 0x60, 0x52, 0x80, 0x00, 0x90, 0x04, 0x49, 0xe0, 0x70, 0x53, 0x90,
0x04, 0x00, 0xe0, 0xfe, 0xa3, 0xe0, 0x78, 0x02, 0xce, 0xc3, 0x13, 0xce,
0x13, 0xd8, 0xf9, 0x30, 0xe0, 0x40, 0x90, 0x04, 0x5f, 0xe0, 0x70, 0x20,
0x7f, 0x09, 0x12, 0x71, 0xfa, 0x90, 0x04, 0x5f, 0x74, 0x01, 0xf0, 0x90,
0x04, 0x40, 0x74, 0x17, 0xf0, 0x90, 0x04, 0x83, 0x74, 0xff, 0xf0, 0x12,
0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0x7f, 0x09, 0x12, 0x63,
0xa3, 0x90, 0x04, 0x40, 0x74, 0x18, 0xf0, 0x90, 0x04, 0x83, 0x74, 0xff,
0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22, 0x90, 0x04,
0x40, 0x74, 0x19, 0xf0, 0x7f, 0x00, 0x22, 0x90, 0x04, 0x49, 0xe0, 0x70,
0x02, 0x80, 0x4c, 0x90, 0x04, 0x24, 0xe0, 0xf4, 0x70, 0x04, 0xa3, 0xe0,
0x64, 0xef, 0x70, 0x12, 0x7f, 0xc1, 0x12, 0x6e, 0xc9, 0x7f, 0x01, 0x12,
0x6e, 0xc9, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x80, 0x1c, 0x90, 0x04,
0x24, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x0f, 0x70, 0x15, 0x7f, 0xc1,
0x12, 0x6e, 0xc9, 0x7f, 0x01, 0x12, 0x6e, 0xc9, 0x75, 0xa5, 0x08, 0x75,
0xa6, 0xff, 0x75, 0x9a, 0x32, 0x80, 0x18, 0x75, 0xa5, 0x02, 0x75, 0xa6,
0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a, 0x04, 0x75, 0xa5, 0x02, 0x75, 0xa6,
0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a, 0x04, 0x90, 0x04, 0x25, 0xe0, 0x04,
0xf0, 0x70, 0x06, 0x90, 0x04, 0x24, 0xe0, 0x04, 0xf0, 0x22, 0x8b, 0x1d,
0x8a, 0x1e, 0x89, 0x1f, 0x7f, 0xda, 0x12, 0x78, 0xb8, 0xee, 0x54, 0x7f,
0xfe, 0xe4, 0x8f, 0x23, 0x8e, 0x22, 0xf5, 0x21, 0xf5, 0x20, 0xad, 0x21,
0xac, 0x20, 0x78, 0x0f, 0x12, 0x26, 0x3b, 0xab, 0x1d, 0xaa, 0x1e, 0xa9,
0x1f, 0xef, 0x12, 0x25, 0xf0, 0x7f, 0xdb, 0x12, 0x78, 0xb8, 0xe4, 0xfc,
0xfd, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0xaf, 0x23, 0xae,
0x22, 0xad, 0x21, 0xac, 0x20, 0x78, 0x10, 0x12, 0x26, 0x4e, 0xd0, 0x03,
0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xef, 0x4b, 0xf5, 0x23, 0xee, 0x4a,
0xf5, 0x22, 0xed, 0x49, 0xf5, 0x21, 0xec, 0x48, 0xf5, 0x20, 0xe5, 0x23,
0xff, 0xe5, 0x22, 0xfe, 0xe5, 0x21, 0xfd, 0xe5, 0x20, 0x54, 0x7f, 0xfc,
0x22, 0xef, 0x24, 0xfe, 0x60, 0x1c, 0x14, 0x60, 0x2a, 0x14, 0x60, 0x3a,
0x14, 0x60, 0x4b, 0x24, 0x04, 0x70, 0x57, 0x90, 0x04, 0x88, 0xe0, 0x7f,
0x00, 0x20, 0xe0, 0x02, 0x7f, 0x01, 0xae, 0x07, 0x80, 0x48, 0x90, 0x04,
0x88, 0xe0, 0xc3, 0x13, 0x7f, 0x00, 0x20, 0xe0, 0x02, 0x7f, 0x01, 0xae,
0x07, 0x80, 0x37, 0x90, 0x04, 0x88, 0xe0, 0x13, 0x13, 0x54, 0x3f, 0x7f,
0x00, 0x20, 0xe0, 0x02, 0x7f, 0x01, 0xae, 0x07, 0x80, 0x24, 0x90, 0x04,
0x88, 0xe0, 0x13, 0x13, 0x13, 0x54, 0x1f, 0x7f, 0x00, 0x20, 0xe0, 0x02,
0x7f, 0x01, 0xae, 0x07, 0x80, 0x10, 0x90, 0x04, 0x88, 0xe0, 0xc4, 0x54,
0x0f, 0x7f, 0x00, 0x20, 0xe0, 0x02, 0x7f, 0x01, 0xae, 0x07, 0xaf, 0x06,
0x22, 0x90, 0x04, 0x17, 0xe0, 0x30, 0xe2, 0x3f, 0x20, 0xe1, 0x32, 0x90,
0x04, 0x79, 0xe0, 0xff, 0x12, 0x78, 0xf8, 0xef, 0x33, 0x95, 0xe0, 0xef,
0x54, 0x3f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x43, 0x90, 0x04, 0x78, 0xe0, 0xff, 0x12, 0x78, 0xf8, 0xef, 0x54, 0x3f,
0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x44, 0x80,
0x1a, 0x90, 0x04, 0x45, 0xe0, 0xff, 0x12, 0x63, 0x09, 0x80, 0x10, 0x90,
0x04, 0x4f, 0xe0, 0xff, 0x12, 0x73, 0x80, 0x90, 0x04, 0x46, 0xe0, 0xff,
0x12, 0x5f, 0x3c, 0x90, 0x04, 0x17, 0xe0, 0x30, 0xe3, 0x0d, 0x75, 0xa4,
0x08, 0x75, 0xa6, 0xf7, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x40, 0x22, 0x22,
0xe4, 0xff, 0xfe, 0x90, 0x04, 0x16, 0xe0, 0xfd, 0x90, 0x04, 0x77, 0xe0,
0xfc, 0xc3, 0x9d, 0x40, 0x05, 0xec, 0x9d, 0xfd, 0x80, 0x0b, 0x90, 0x04,
0x16, 0xe0, 0xfd, 0xc3, 0x74, 0xbf, 0x9d, 0x2c, 0xfd, 0x90, 0x04, 0x24,
0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x63, 0x70, 0x03, 0x43, 0x06, 0x80,
0x90, 0x04, 0x77, 0xe0, 0xfc, 0xc3, 0x94, 0xbf, 0x40, 0x04, 0x7c, 0x00,
0x80, 0x03, 0xec, 0x04, 0xfc, 0x90, 0x04, 0x16, 0xe0, 0xb5, 0x04, 0x03,
0x43, 0x06, 0x40, 0x90, 0x04, 0x16, 0xe0, 0xfb, 0x90, 0x04, 0x77, 0xe0,
0xb5, 0x03, 0x03, 0x43, 0x06, 0x20, 0xed, 0xfb, 0xeb, 0x4f, 0xff, 0x90,
0x04, 0x14, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0xaf, 0x04, 0x22, 0xad, 0x07,
0xe4, 0xfc, 0xd3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x40, 0x1b, 0xec, 0xf5,
0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x45, 0xec, 0x54,
0x3f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x46,
0x22, 0xc3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x50, 0x1d, 0xec, 0x54, 0x3f,
0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x47, 0xec,
0x54, 0x3f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x48, 0x22, 0xec, 0x54, 0x3f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0x43, 0xec, 0x54, 0x3f, 0xf5, 0xa4, 0x75, 0xa6, 0xc0,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x44, 0x22, 0x90, 0x04, 0x50, 0xe0, 0xff,
0x7d, 0x06, 0xef, 0x24, 0xfe, 0x60, 0x11, 0x14, 0x60, 0x12, 0x14, 0x60,
0x13, 0x14, 0x60, 0x14, 0x24, 0x04, 0x70, 0x14, 0x7c, 0x08, 0x80, 0x12,
0x7c, 0x10, 0x80, 0x0e, 0x7c, 0x20, 0x80, 0x0a, 0x7c, 0x40, 0x80, 0x06,
0x7c, 0x80, 0x80, 0x02, 0xe4, 0xfc, 0x12, 0x76, 0x5e, 0xed, 0x54, 0x1f,
0xf5, 0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75,
0xa4, 0x20, 0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xd3, 0x75, 0xa7, 0x8b, 0x75,
0x9a, 0x30, 0x75, 0xa4, 0x20, 0x75, 0xa5, 0x20, 0x75, 0x9a, 0x31, 0xec,
0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x22, 0x74, 0xff, 0xf5,
0x18, 0xf5, 0x19, 0x7f, 0x0e, 0x12, 0x78, 0xb8, 0x8e, 0x1a, 0x8f, 0x1b,
0xe4, 0xf5, 0x1c, 0xf5, 0x1d, 0xf5, 0x16, 0xf5, 0x17, 0xc3, 0xe5, 0x17,
0x95, 0x1b, 0xe5, 0x16, 0x95, 0x1a, 0x50, 0x39, 0xe5, 0x18, 0xff, 0xe5,
0x1d, 0x25, 0x17, 0xf5, 0x82, 0xe5, 0x1c, 0x35, 0x16, 0xf5, 0x83, 0xe4,
0x93, 0x6f, 0xfd, 0xe5, 0x19, 0xfe, 0x75, 0xf0, 0x02, 0xed, 0xa4, 0x24,
0xfa, 0xf5, 0x82, 0xe5, 0xf0, 0x34, 0x78, 0xf5, 0x83, 0xe4, 0x93, 0x6e,
0xf5, 0x18, 0x74, 0x01, 0x93, 0xf5, 0x19, 0x05, 0x17, 0xe5, 0x17, 0x70,
0xc0, 0x05, 0x16, 0x80, 0xbc, 0xae, 0x18, 0xaf, 0x19, 0x22, 0xae, 0x29,
0xac, 0x2a, 0xab, 0x2b, 0xaa, 0x2c, 0xed, 0x70, 0x04, 0xae, 0x2a, 0xac,
0x29, 0xbf, 0x01, 0x18, 0xee, 0xc3, 0x94, 0x07, 0x50, 0x03, 0x0e, 0x80,
0x29, 0xec, 0xd3, 0x94, 0x00, 0x40, 0x01, 0x1c, 0xeb, 0xc3, 0x9a, 0x50,
0x1d, 0x0b, 0x80, 0x1a, 0xbf, 0xff, 0x17, 0xee, 0xd3, 0x94, 0x00, 0x40,
0x03, 0x1e, 0x80, 0x0e, 0xec, 0xc3, 0x94, 0x07, 0x50, 0x01, 0x0c, 0xeb,
0xd3, 0x94, 0x00, 0x40, 0x01, 0x1b, 0x8b, 0x31, 0xed, 0x70, 0x06, 0x8e,
0x30, 0x8c, 0x2f, 0x80, 0x04, 0x8e, 0x2f, 0x8c, 0x30, 0x85, 0x27, 0x2d,
0x85, 0x28, 0x2e, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x2d, 0x22, 0x12, 0x78,
0x36, 0x90, 0x04, 0x4f, 0xef, 0xf0, 0x7f, 0x1f, 0x12, 0x73, 0x80, 0x90,
0x04, 0x24, 0x74, 0xff, 0xf0, 0xa3, 0x74, 0xe1, 0xf0, 0x90, 0x04, 0x49,
0xe0, 0x70, 0x09, 0x7f, 0xe0, 0x12, 0x6e, 0xc9, 0x7f, 0x01, 0x80, 0x02,
0x7f, 0x02, 0x12, 0x6e, 0xc9, 0xe4, 0x90, 0x04, 0x26, 0xf0, 0xa3, 0xf0,
0x90, 0x04, 0x77, 0xf0, 0x90, 0x04, 0x16, 0xf0, 0x7f, 0x1f, 0x12, 0x72,
0xab, 0x90, 0x04, 0x49, 0xe0, 0xd3, 0x94, 0x00, 0x40, 0x09, 0x75, 0xa5,
0x02, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0xe4, 0x90, 0x04, 0x14, 0xf0,
0xa3, 0xf0, 0x22, 0xad, 0x07, 0x75, 0xa4, 0x01, 0xd3, 0xed, 0x64, 0x80,
0x94, 0x80, 0x40, 0x04, 0x7f, 0x01, 0x80, 0x02, 0x7f, 0x00, 0xef, 0x25,
0xe0, 0x25, 0xe0, 0x54, 0x04, 0x44, 0x40, 0xfe, 0xee, 0xf5, 0xa5, 0x75,
0xa6, 0x80, 0x75, 0xa7, 0x8b, 0x75, 0x9a, 0x04, 0xe4, 0xff, 0xd3, 0xed,
0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xae, 0x05, 0x80, 0x04, 0xed, 0xf4,
0x04, 0xfe, 0xc3, 0xee, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80, 0x98, 0x50,
0x0f, 0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfd, 0x75, 0x9a,
0x04, 0x0f, 0x80, 0xd6, 0x22, 0xad, 0x07, 0x75, 0xa4, 0x01, 0xd3, 0xed,
0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0x7f, 0x01, 0x80, 0x02, 0x7f, 0x00,
0xef, 0x25, 0xe0, 0x25, 0xe0, 0x54, 0x04, 0x44, 0x20, 0xfe, 0xee, 0xf5,
0xa5, 0x75, 0xa6, 0x80, 0x75, 0xa7, 0x8b, 0x75, 0x9a, 0x04, 0xe4, 0xff,
0xd3, 0xed, 0x64, 0x80, 0x94, 0x80, 0x40, 0x04, 0xae, 0x05, 0x80, 0x04,
0xed, 0xf4, 0x04, 0xfe, 0xc3, 0xee, 0x64, 0x80, 0xf8, 0xef, 0x64, 0x80,
0x98, 0x50, 0x0f, 0x75, 0xa5, 0x02, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfd,
0x75, 0x9a, 0x04, 0x0f, 0x80, 0xd6, 0x22, 0xad, 0x07, 0xed, 0xd3, 0x94,
0x0d, 0x50, 0x21, 0xed, 0x24, 0xfa, 0xff, 0x74, 0x01, 0x7e, 0x00, 0xa8,
0x07, 0x08, 0x80, 0x05, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8, 0xf9, 0xf5,
0xa5, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x75, 0xa4, 0x04, 0x80, 0x1f,
0xed, 0x24, 0xf2, 0xff, 0x74, 0x01, 0x7e, 0x00, 0xa8, 0x07, 0x08, 0x80,
0x05, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8, 0xf9, 0xf5, 0xa5, 0x75, 0xa6,
0xff, 0x75, 0x9a, 0x32, 0x75, 0xa4, 0x08, 0x75, 0xa6, 0xf3, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0x30, 0x22, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xf6, 0x60,
0x32, 0x80, 0x00, 0x90, 0x04, 0x87, 0xe0, 0xff, 0xc3, 0x13, 0x20, 0xe0,
0x38, 0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0x80, 0x75, 0xa7, 0xff, 0x75, 0x9a,
0x49, 0x90, 0x04, 0x49, 0xe0, 0xd3, 0x94, 0x01, 0x50, 0x23, 0x12, 0x71,
0x32, 0x7f, 0x10, 0x12, 0x75, 0x8f, 0x12, 0x75, 0x3a, 0x90, 0x04, 0x40,
0x74, 0x0a, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22,
0x12, 0x5b, 0x03, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe5, 0x7f, 0x00, 0x22,
0xe4, 0xf5, 0x36, 0xf5, 0x37, 0x12, 0x78, 0xa0, 0x7f, 0xf4, 0x12, 0x78,
0xe6, 0xef, 0xc4, 0x13, 0x13, 0x13, 0x54, 0x01, 0x60, 0xf2, 0x7f, 0xfa,
0x12, 0x78, 0xe6, 0xef, 0xc4, 0x54, 0x0f, 0xf5, 0x08, 0x12, 0x61, 0xcd,
0xe4, 0xf5, 0x38, 0xe5, 0x38, 0xc3, 0x95, 0x08, 0x50, 0x0a, 0x85, 0x38,
0xb1, 0x12, 0x66, 0xce, 0x05, 0x38, 0x80, 0xef, 0xe4, 0xf5, 0x38, 0x85,
0x38, 0xb1, 0x12, 0x00, 0x06, 0x05, 0x38, 0xe5, 0x38, 0xb5, 0x08, 0xf3,
0xe4, 0xf5, 0x38, 0x80, 0xee, 0x8f, 0x15, 0x8e, 0x14, 0x8d, 0x13, 0x8c,
0x12, 0x90, 0xe0, 0x00, 0x74, 0x04, 0xf0, 0x90, 0xe0, 0x02, 0xef, 0xf0,
0x78, 0x08, 0x12, 0x26, 0x3b, 0xa3, 0xef, 0xf0, 0xaf, 0x15, 0xae, 0x14,
0xad, 0x13, 0xac, 0x12, 0x78, 0x10, 0x12, 0x26, 0x3b, 0xa3, 0xef, 0xf0,
0xaf, 0x15, 0xae, 0x14, 0xad, 0x13, 0xac, 0x12, 0x78, 0x18, 0x12, 0x26,
0x3b, 0xa3, 0xef, 0xf0, 0x90, 0xe0, 0x00, 0x74, 0x05, 0xf0, 0x90, 0xe0,
0x00, 0xe0, 0x20, 0xe0, 0xf9, 0x22, 0x90, 0x04, 0x40, 0xe0, 0x24, 0xf2,
0x60, 0x26, 0x80, 0x00, 0x90, 0x04, 0x87, 0xe0, 0xff, 0xc3, 0x13, 0x20,
0xe0, 0x2c, 0x90, 0x04, 0x49, 0xe0, 0xd3, 0x94, 0x01, 0x50, 0x23, 0x12,
0x71, 0x32, 0x7f, 0x10, 0x12, 0x75, 0x8f, 0x12, 0x75, 0x3a, 0x90, 0x04,
0x40, 0x74, 0x0e, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02,
0x22, 0x12, 0x5b, 0x03, 0x90, 0x04, 0x4d, 0xe0, 0x60, 0xe5, 0x90, 0x04,
0x40, 0x74, 0x2f, 0xf0, 0x7f, 0x00, 0x22, 0x90, 0x04, 0x60, 0xe0, 0xfb,
0x7a, 0x00, 0x7e, 0x00, 0x8f, 0x82, 0x8e, 0x83, 0xaf, 0x05, 0xeb, 0xae,
0x02, 0xa8, 0x07, 0x08, 0x80, 0x05, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8,
0xf9, 0xff, 0xee, 0x55, 0x83, 0xfe, 0xef, 0x55, 0x82, 0xff, 0xe5, 0x82,
0xf4, 0xfd, 0xe5, 0x83, 0xf4, 0xfc, 0x90, 0x04, 0x2e, 0xe0, 0x5c, 0xfc,
0xa3, 0xe0, 0x5d, 0xfd, 0xec, 0x4e, 0xfe, 0xed, 0x4f, 0xff, 0x90, 0x04,
0x2e, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0x90, 0x04, 0x7f, 0xe0, 0xff,
0xc3, 0x13, 0x30, 0xe0, 0x03, 0x7f, 0x00, 0x22, 0x90, 0x04, 0x40, 0xe0,
0x24, 0xf3, 0x60, 0x0b, 0x80, 0x00, 0x12, 0x73, 0x4c, 0x90, 0x04, 0x40,
0x74, 0x0d, 0xf0, 0x12, 0x78, 0xac, 0xef, 0x70, 0x03, 0x7f, 0x02, 0x22,
0x12, 0x77, 0x62, 0xef, 0x60, 0x16, 0x75, 0xa4, 0x01, 0x75, 0xa6, 0xfe,
0x75, 0xa7, 0xff, 0x75, 0x9a, 0x19, 0x7d, 0x01, 0x7f, 0x17, 0x12, 0x34,
0x1e, 0x7f, 0x01, 0x22, 0x7f, 0x00, 0x22, 0x12, 0x6c, 0x8e, 0xe4, 0x90,
0x04, 0x1c, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x4b,
0xf0, 0x90, 0x04, 0x4d, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3,
0xf0, 0x90, 0x04, 0x53, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x7b, 0xe0, 0x64,
0x01, 0x60, 0x0d, 0xe4, 0x90, 0x04, 0x20, 0xf0, 0xa3, 0xf0, 0x90, 0x04,
0x24, 0xf0, 0xa3, 0xf0, 0xe4, 0x90, 0x04, 0x22, 0xf0, 0xa3, 0xf0, 0x90,
0x04, 0x26, 0xf0, 0xa3, 0xf0, 0x22, 0x12, 0x76, 0xf7, 0xe4, 0x8f, 0x2b,
0x8e, 0x2a, 0xf5, 0x29, 0xf5, 0x28, 0x90, 0x00, 0x60, 0xe0, 0x30, 0xe0,
0x11, 0x54, 0xfe, 0xf0, 0x90, 0x00, 0x67, 0xe0, 0x04, 0xf0, 0x70, 0x06,
0x90, 0x00, 0x66, 0xe0, 0x04, 0xf0, 0x90, 0x00, 0x66, 0xe0, 0xfe, 0xa3,
0xe0, 0xff, 0xe4, 0xfc, 0xfd, 0x78, 0x10, 0x12, 0x26, 0x4e, 0xef, 0x45,
0x2b, 0xff, 0xee, 0x45, 0x2a, 0xfe, 0xed, 0x45, 0x29, 0xfd, 0xec, 0x45,
0x28, 0xfc, 0x22, 0x8f, 0x82, 0x8e, 0x83, 0xaf, 0x05, 0xeb, 0xae, 0x02,
0xa8, 0x07, 0x08, 0x80, 0x05, 0xc3, 0x33, 0xce, 0x33, 0xce, 0xd8, 0xf9,
0xff, 0xee, 0x55, 0x83, 0xfe, 0xef, 0x55, 0x82, 0xff, 0xe5, 0x82, 0xf4,
0xfd, 0xe5, 0x83, 0xf4, 0xfc, 0x90, 0x04, 0x30, 0xe0, 0x5c, 0xfc, 0xa3,
0xe0, 0x5d, 0xfd, 0xec, 0x4e, 0xfe, 0xed, 0x4f, 0xff, 0x90, 0x04, 0x30,
0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xef, 0x25, 0xe0, 0x25, 0xe0, 0xf5,
0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x83, 0x75, 0x9a, 0x14, 0xe4, 0xf5,
0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x21, 0x90, 0x04,
0x88, 0xe0, 0x20, 0xe0, 0x19, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75,
0xa7, 0x7f, 0x75, 0x9a, 0x21, 0x75, 0xa4, 0x40, 0x75, 0xa6, 0xbf, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x10, 0x22, 0x22, 0x7f, 0x3b, 0x12, 0x78, 0xe6,
0xef, 0x54, 0x07, 0xff, 0x7e, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0x7f, 0x3b,
0x12, 0x78, 0xe6, 0xef, 0x54, 0x3f, 0x13, 0x13, 0x13, 0x54, 0x1f, 0xfd,
0xd0, 0xe0, 0x2d, 0xff, 0xd0, 0xe0, 0x34, 0x00, 0xc3, 0x13, 0xef, 0x13,
0xff, 0xc0, 0x07, 0x7f, 0x3b, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xfe,
0xd0, 0xe0, 0x2e, 0xff, 0x22, 0x90, 0x04, 0x0f, 0xe0, 0x13, 0x13, 0x13,
0x54, 0x1f, 0xd3, 0x94, 0x01, 0x40, 0x29, 0xa3, 0xe0, 0x13, 0x13, 0x13,
0x54, 0x1f, 0xd3, 0x94, 0x01, 0x40, 0x1d, 0x90, 0x04, 0x0d, 0xe0, 0x13,
0x13, 0x13, 0x54, 0x1f, 0xd3, 0x94, 0x01, 0x40, 0x0f, 0xa3, 0xe0, 0x13,
0x13, 0x13, 0x54, 0x1f, 0xd3, 0x94, 0x01, 0x40, 0x03, 0x7f, 0x00, 0x22,
0x7f, 0x01, 0x22, 0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5, 0xa4, 0x75,
0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0xe4, 0xf5, 0xa4, 0x75,
0xa5, 0x30, 0x75, 0xa6, 0xf3, 0x75, 0xa7, 0x8f, 0x75, 0x9a, 0x30, 0x75,
0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x75, 0xa4, 0x03, 0x75,
0xa6, 0xfc, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x33, 0x22, 0x90, 0x04, 0x56,
0xe0, 0xff, 0x12, 0x78, 0xf3, 0x90, 0x04, 0x57, 0xe0, 0xff, 0x12, 0x73,
0x80, 0xe4, 0x90, 0x04, 0x44, 0xf0, 0xa3, 0xe0, 0xff, 0x12, 0x63, 0x09,
0x90, 0x04, 0x46, 0xe0, 0xff, 0x12, 0x5f, 0x3c, 0x75, 0xa4, 0x20, 0x75,
0xa6, 0xdf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10, 0x90, 0x04, 0x44, 0x74,
0x01, 0xf0, 0x22, 0x12, 0x71, 0x76, 0x8f, 0x1c, 0x8e, 0x1b, 0x8d, 0x1a,
0x8c, 0x19, 0xaa, 0x1b, 0xab, 0x1c, 0x90, 0x04, 0x36, 0xea, 0xf0, 0xa3,
0xeb, 0xf0, 0x78, 0x10, 0x12, 0x26, 0x3b, 0x90, 0x04, 0x34, 0xee, 0xf0,
0xa3, 0xef, 0xf0, 0x90, 0x04, 0x22, 0xea, 0xf0, 0xa3, 0xeb, 0xf0, 0x90,
0x04, 0x20, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0x75, 0xa5, 0x02, 0x75,
0xa6, 0xff, 0x75, 0xa7, 0xf8, 0x75, 0x9a, 0x01, 0x7f, 0x06, 0x12, 0x78,
0xe6, 0xef, 0x54, 0x01, 0xf5, 0x13, 0x12, 0x76, 0x5e, 0x75, 0xa4, 0x10,
0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75, 0xa5, 0x80,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x30, 0x02, 0x75, 0x3a,
0xad, 0x07, 0xed, 0xff, 0x33, 0x95, 0xe0, 0xfe, 0xef, 0x78, 0x03, 0xc3,
0x33, 0xce, 0x33, 0xce, 0xd8, 0xf9, 0xf5, 0xa4, 0xee, 0x54, 0x01, 0x44,
0x1a, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75, 0xa5, 0x80,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0x90, 0x04, 0x57,
0xed, 0xf0, 0x22, 0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5, 0xa4, 0x75,
0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75, 0xa4, 0x20, 0x75,
0xa5, 0xa0, 0x75, 0xa6, 0xd3, 0x75, 0xa7, 0x0f, 0x75, 0x9a, 0x30, 0x75,
0xa4, 0x20, 0x75, 0xa5, 0x20, 0x75, 0x9a, 0x31, 0x75, 0xa5, 0x04, 0x75,
0xa6, 0xff, 0x75, 0x9a, 0x32, 0x22, 0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f,
0xf5, 0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75,
0xa4, 0x0c, 0x75, 0xa5, 0x30, 0x75, 0xa6, 0xf3, 0x75, 0xa7, 0x8f, 0x75,
0x9a, 0x30, 0x75, 0xa4, 0x20, 0x75, 0xa5, 0x20, 0x75, 0x9a, 0x31, 0x75,
0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x22, 0x12, 0x76, 0x5e,
0xef, 0x54, 0x1f, 0xf5, 0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75,
0x9a, 0x15, 0xe4, 0xf5, 0xa4, 0x75, 0xa5, 0x24, 0x75, 0xa6, 0xf3, 0x75,
0xa7, 0x8b, 0x75, 0x9a, 0x30, 0x75, 0xa4, 0x60, 0x75, 0xa5, 0x20, 0x75,
0x9a, 0x31, 0x75, 0xa5, 0x38, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x22,
0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5, 0xa4, 0x75, 0xa6, 0xe0, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75, 0xa4, 0x0c, 0x75, 0xa5, 0x30, 0x75,
0xa6, 0xf3, 0x75, 0xa7, 0x8f, 0x75, 0x9a, 0x30, 0x75, 0xa4, 0x60, 0x75,
0xa5, 0x60, 0x75, 0x9a, 0x31, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75,
0x9a, 0x32, 0x22, 0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5, 0xa4, 0x75,
0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75, 0xa4, 0x0c, 0x75,
0xa5, 0x30, 0x75, 0xa6, 0xf3, 0x75, 0xa7, 0x8f, 0x75, 0x9a, 0x30, 0x75,
0xa4, 0x60, 0x75, 0xa5, 0x20, 0x75, 0x9a, 0x31, 0x75, 0xa5, 0x04, 0x75,
0xa6, 0xff, 0x75, 0x9a, 0x32, 0x22, 0x12, 0x6b, 0xb9, 0x12, 0x76, 0x5e,
0xe4, 0xf5, 0xa4, 0x75, 0xa6, 0xcf, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x11,
0xe4, 0xf5, 0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfb, 0x75, 0x9a, 0xd1,
0xe4, 0x90, 0x04, 0x17, 0xf0, 0x90, 0x04, 0x16, 0xf0, 0x90, 0x04, 0x14,
0xf0, 0xa3, 0xf0, 0x22, 0xad, 0x07, 0x90, 0x04, 0x7f, 0xe0, 0xc4, 0x54,
0x0f, 0x20, 0xe0, 0x13, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0,
0x13, 0x54, 0x1f, 0xd3, 0x94, 0x16, 0xe4, 0x94, 0x00, 0x40, 0x07, 0xed,
0x90, 0x7b, 0xb9, 0x93, 0xff, 0x22, 0xed, 0x90, 0x7b, 0xa4, 0x93, 0xff,
0x22, 0xad, 0x07, 0x90, 0x04, 0x7f, 0xe0, 0xc4, 0x54, 0x0f, 0x20, 0xe0,
0x13, 0x90, 0x00, 0x50, 0xe0, 0xc3, 0x13, 0xa3, 0xe0, 0x13, 0x54, 0x1f,
0xd3, 0x94, 0x16, 0xe4, 0x94, 0x00, 0x40, 0x07, 0xed, 0x90, 0x7b, 0xe3,
0x93, 0xff, 0x22, 0xed, 0x90, 0x7b, 0xce, 0x93, 0xff, 0x22, 0xe4, 0xf5,
0xa5, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x30, 0x75, 0xa5,
0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x30, 0x75, 0xa4,
0x80, 0x75, 0xa6, 0x7f, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x10, 0x90, 0x04,
0x83, 0x74, 0xff, 0xf0, 0x22, 0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5,
0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75, 0xa4,
0x0c, 0x75, 0xa5, 0xb0, 0x75, 0xa6, 0xf3, 0x75, 0xa7, 0x0f, 0x75, 0x9a,
0x30, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x22, 0x12,
0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5, 0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0x15, 0x75, 0xa4, 0x0c, 0x75, 0xa5, 0xa0, 0x75, 0xa6,
0xf3, 0x75, 0xa7, 0x0f, 0x75, 0x9a, 0x30, 0x75, 0xa5, 0x04, 0x75, 0xa6,
0xff, 0x75, 0x9a, 0x32, 0x22, 0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5,
0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0xe4, 0xf5,
0xa4, 0x75, 0xa5, 0x90, 0x75, 0xa6, 0xf3, 0x75, 0xa7, 0x0f, 0x75, 0x9a,
0x30, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0x9a, 0x32, 0x22, 0x12,
0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5, 0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0x15, 0x75, 0xa5, 0x80, 0x75, 0xa6, 0xff, 0x75, 0xa7,
0x7f, 0x75, 0x9a, 0x30, 0x75, 0xa4, 0x80, 0x75, 0xa6, 0x7f, 0x75, 0xa7,
0xff, 0x75, 0x9a, 0x10, 0x22, 0x12, 0x32, 0x25, 0x12, 0x59, 0x71, 0xe4,
0xfd, 0x7f, 0x01, 0x12, 0x2e, 0x0a, 0xe4, 0xfd, 0x7f, 0x02, 0x12, 0x2e,
0x0a, 0xe4, 0xfd, 0x7f, 0x03, 0x12, 0x2e, 0x0a, 0xe4, 0xfd, 0x7f, 0x04,
0x12, 0x2e, 0x0a, 0xe4, 0xfd, 0x7f, 0x05, 0x02, 0x2e, 0x0a, 0x75, 0xa4,
0x06, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0xd0, 0x75, 0xa4,
0x10, 0x75, 0xa6, 0xef, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x40, 0x75, 0xa4,
0x50, 0x75, 0xa6, 0x03, 0x75, 0xa7, 0xff, 0x75, 0x9e, 0xd1, 0x75, 0x9c,
0x18, 0x22, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0xa6, 0x03, 0x75, 0xa7,
0x01, 0x75, 0x9a, 0x30, 0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0x9a, 0x31,
0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0x9a, 0x32, 0xe4, 0xf5, 0xa4, 0xf5,
0xa5, 0x75, 0x9a, 0x33, 0x22, 0x12, 0x76, 0x5e, 0xef, 0x54, 0x1f, 0xf5,
0xa4, 0x75, 0xa6, 0xe0, 0x75, 0xa7, 0xff, 0x75, 0x9a, 0x15, 0x75, 0xa5,
0x24, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0x8b, 0x75, 0x9a, 0x30, 0x75, 0xa4,
0x60, 0x75, 0xa5, 0x20, 0x75, 0x9a, 0x31, 0x22, 0xad, 0x07, 0xac, 0x06,
0xe4, 0xf5, 0xa4, 0xf5, 0xa5, 0x75, 0x9a, 0x60, 0xed, 0xf5, 0xa4, 0xec,
0x44, 0x80, 0xf5, 0xa5, 0x75, 0x9a, 0x60, 0xaf, 0x05, 0xed, 0x7d, 0x02,
0x12, 0x40, 0x1f, 0x7d, 0x02, 0x7f, 0x0a, 0x02, 0x34, 0x1e, 0x90, 0x04,
0x4c, 0xe0, 0xb4, 0x01, 0x0d, 0x90, 0x04, 0x08, 0xe0, 0x90, 0x04, 0x87,
0xf0, 0x90, 0x04, 0x09, 0x80, 0x0b, 0x90, 0x04, 0x06, 0xe0, 0x90, 0x04,
0x87, 0xf0, 0x90, 0x04, 0x07, 0xe0, 0x90, 0x04, 0x88, 0xf0, 0x22, 0x85,
0xbf, 0x2c, 0xaf, 0xcb, 0xef, 0xfe, 0xad, 0xca, 0xed, 0xac, 0x06, 0xc3,
0x95, 0x37, 0xec, 0x95, 0x36, 0x50, 0x07, 0x90, 0x00, 0x60, 0xe0, 0x44,
0x01, 0xf0, 0x8c, 0x36, 0x8d, 0x37, 0xae, 0x04, 0xaf, 0x05, 0x22, 0x7f,
0xa9, 0x12, 0x78, 0xe6, 0xef, 0x54, 0x0f, 0xff, 0xc3, 0x94, 0x03, 0x40,
0x06, 0xef, 0xd3, 0x94, 0x0d, 0x40, 0x08, 0x90, 0x00, 0x60, 0xe0, 0x44,
0x10, 0xf0, 0x22, 0x90, 0x00, 0x60, 0xe0, 0x54, 0xef, 0xf0, 0x22, 0xad,
0x07, 0xed, 0x75, 0xf0, 0x08, 0xa4, 0xae, 0xf0, 0xf5, 0xa4, 0xee, 0x54,
0x01, 0xf5, 0xa5, 0x75, 0xa7, 0xc0, 0x75, 0x9a, 0x2b, 0x75, 0xa5, 0x80,
0x75, 0xa6, 0xff, 0x75, 0xa7, 0x7f, 0x75, 0x9a, 0x2b, 0x22, 0x7f, 0x06,
0x12, 0x78, 0xe6, 0xef, 0x54, 0x01, 0xf5, 0x13, 0x7f, 0x05, 0x12, 0x78,
0xb8, 0xe5, 0x13, 0x60, 0x0b, 0xc3, 0xee, 0x64, 0x80, 0x94, 0x80, 0x50,
0x03, 0x75, 0x13, 0xff, 0xaf, 0x13, 0x22, 0x12, 0x71, 0x76, 0x8f, 0x20,
0x8e, 0x1f, 0x8d, 0x1e, 0x8c, 0x1d, 0x90, 0x04, 0x22, 0xee, 0xf0, 0xa3,
0xef, 0xf0, 0x78, 0x10, 0x12, 0x26, 0x3b, 0x90, 0x04, 0x20, 0xee, 0xf0,
0xa3, 0xef, 0xf0, 0x22, 0x12, 0x35, 0xf7, 0xad, 0x07, 0xac, 0x06, 0xed,
0x25, 0xe0, 0xfb, 0xec, 0x33, 0xfa, 0xed, 0x78, 0x02, 0xc3, 0x33, 0xce,
0x33, 0xce, 0xd8, 0xf9, 0x2b, 0xff, 0xee, 0x3a, 0xfe, 0x22, 0x7f, 0x1f,
0x12, 0x72, 0xab, 0x75, 0xa4, 0x10, 0x75, 0xa6, 0xcf, 0x75, 0xa7, 0xff,
0x75, 0x9a, 0x11, 0x75, 0xa5, 0x04, 0x75, 0xa6, 0xff, 0x75, 0xa7, 0xfb,
0x75, 0x9a, 0xd1, 0x22, 0xab, 0x07, 0xaa, 0x06, 0xea, 0x5c, 0xfe, 0xeb,
0x5d, 0x25, 0xe0, 0xff, 0xee, 0x33, 0xfe, 0xc3, 0xeb, 0x9f, 0xff, 0xea,
0x9e, 0xfe, 0x22, 0x90, 0xe0, 0x00, 0x74, 0x04, 0xf0, 0x04, 0xf0, 0x90,
0xe0, 0x00, 0xe0, 0x20, 0xe0, 0xf9, 0x90, 0xe0, 0x00, 0x74, 0x06, 0xf0,
0x22, 0x12, 0x78, 0x36, 0x90, 0x04, 0x4f, 0xef, 0xf0, 0xe4, 0x90, 0x04,
0x77, 0xf0, 0x90, 0x04, 0x16, 0xf0, 0x7f, 0x1c, 0x02, 0x75, 0x65, 0xef,
0xc4, 0x33, 0x33, 0x33, 0x54, 0x80, 0xf5, 0xa4, 0x75, 0xa6, 0x7f, 0x75,
0xa7, 0xff, 0x75, 0x9a, 0x90, 0x22, 0x7f, 0x3a, 0x12, 0x78, 0xb8, 0xee,
0x54, 0x3f, 0xfe, 0x7d, 0x00, 0x7c, 0x20, 0x12, 0x77, 0xe0, 0xee, 0xff,
0x22, 0xc3, 0xee, 0x64, 0x80, 0x94, 0x80, 0x50, 0x08, 0xef, 0xf4, 0xff,
0xee, 0xf4, 0xfe, 0x80, 0x00, 0x22, 0xad, 0x07, 0x75, 0xa4, 0xc0, 0xed,
0xfe, 0xee, 0xf5, 0xa5, 0x75, 0xa6, 0x3f, 0x75, 0x9a, 0x0d, 0x22, 0xaf,
0xbc, 0xad, 0x07, 0xe5, 0xbd, 0x54, 0x03, 0xfc, 0xae, 0x04, 0xaf, 0x05,
0x22, 0xad, 0x07, 0x75, 0xa4, 0x80, 0xed, 0xfe, 0xee, 0xf5, 0xa5, 0x75,
0x9a, 0x0d, 0x22, 0x8f, 0x9e, 0x8d, 0x9d, 0xad, 0xa9, 0xaf, 0xaa, 0xef,
0xfe, 0xed, 0xff, 0x22, 0x7f, 0xf9, 0x12, 0x78, 0xb8, 0xac, 0x06, 0x8c,
0x12, 0x02, 0x57, 0xd8, 0xd2, 0xc8, 0xd2, 0xc9, 0xd2, 0xcb, 0xe4, 0xf5,
0xbf, 0xd2, 0xca, 0x22, 0x90, 0x04, 0x83, 0xe0, 0x7f, 0x00, 0xb4, 0x07,
0x02, 0x7f, 0x01, 0x22, 0x8f, 0x9b, 0xad, 0xa9, 0xaf, 0xaa, 0xef, 0xfe,
0xed, 0xff, 0x22, 0x7f, 0x3a, 0x12, 0x78, 0xeb, 0xef, 0x54, 0x3f, 0xff,
0x22, 0x75, 0xa4, 0x80, 0xe4, 0xf5, 0xa5, 0x75, 0x9a, 0x0d, 0x22, 0x90,
0xe0, 0x01, 0xe0, 0x54, 0x01, 0xff, 0x22, 0x8f, 0x9e, 0x8d, 0x9d, 0xaf,
0xa9, 0x22, 0x8f, 0x9b, 0xaf, 0xaa, 0x22, 0x8f, 0x9b, 0xaf, 0xa9, 0x22,
0x7f, 0x00, 0x22, 0x02, 0x77, 0x3f, 0x22, 0x22, 0x22, 0x22, 0x00, 0x00,
0x10, 0x21, 0x20, 0x42, 0x30, 0x63, 0x40, 0x84, 0x50, 0xa5, 0x60, 0xc6,
0x70, 0xe7, 0x81, 0x08, 0x91, 0x29, 0xa1, 0x4a, 0xb1, 0x6b, 0xc1, 0x8c,
0xd1, 0xad, 0xe1, 0xce, 0xf1, 0xef, 0x12, 0x31, 0x02, 0x10, 0x32, 0x73,
0x22, 0x52, 0x52, 0xb5, 0x42, 0x94, 0x72, 0xf7, 0x62, 0xd6, 0x93, 0x39,
0x83, 0x18, 0xb3, 0x7b, 0xa3, 0x5a, 0xd3, 0xbd, 0xc3, 0x9c, 0xf3, 0xff,
0xe3, 0xde, 0x24, 0x62, 0x34, 0x43, 0x04, 0x20, 0x14, 0x01, 0x64, 0xe6,
0x74, 0xc7, 0x44, 0xa4, 0x54, 0x85, 0xa5, 0x6a, 0xb5, 0x4b, 0x85, 0x28,
0x95, 0x09, 0xe5, 0xee, 0xf5, 0xcf, 0xc5, 0xac, 0xd5, 0x8d, 0x36, 0x53,
0x26, 0x72, 0x16, 0x11, 0x06, 0x30, 0x76, 0xd7, 0x66, 0xf6, 0x56, 0x95,
0x46, 0xb4, 0xb7, 0x5b, 0xa7, 0x7a, 0x97, 0x19, 0x87, 0x38, 0xf7, 0xdf,
0xe7, 0xfe, 0xd7, 0x9d, 0xc7, 0xbc, 0x48, 0xc4, 0x58, 0xe5, 0x68, 0x86,
0x78, 0xa7, 0x08, 0x40, 0x18, 0x61, 0x28, 0x02, 0x38, 0x23, 0xc9, 0xcc,
0xd9, 0xed, 0xe9, 0x8e, 0xf9, 0xaf, 0x89, 0x48, 0x99, 0x69, 0xa9, 0x0a,
0xb9, 0x2b, 0x5a, 0xf5, 0x4a, 0xd4, 0x7a, 0xb7, 0x6a, 0x96, 0x1a, 0x71,
0x0a, 0x50, 0x3a, 0x33, 0x2a, 0x12, 0xdb, 0xfd, 0xcb, 0xdc, 0xfb, 0xbf,
0xeb, 0x9e, 0x9b, 0x79, 0x8b, 0x58, 0xbb, 0x3b, 0xab, 0x1a, 0x6c, 0xa6,
0x7c, 0x87, 0x4c, 0xe4, 0x5c, 0xc5, 0x2c, 0x22, 0x3c, 0x03, 0x0c, 0x60,
0x1c, 0x41, 0xed, 0xae, 0xfd, 0x8f, 0xcd, 0xec, 0xdd, 0xcd, 0xad, 0x2a,
0xbd, 0x0b, 0x8d, 0x68, 0x9d, 0x49, 0x7e, 0x97, 0x6e, 0xb6, 0x5e, 0xd5,
0x4e, 0xf4, 0x3e, 0x13, 0x2e, 0x32, 0x1e, 0x51, 0x0e, 0x70, 0xff, 0x9f,
0xef, 0xbe, 0xdf, 0xdd, 0xcf, 0xfc, 0xbf, 0x1b, 0xaf, 0x3a, 0x9f, 0x59,
0x8f, 0x78, 0x91, 0x88, 0x81, 0xa9, 0xb1, 0xca, 0xa1, 0xeb, 0xd1, 0x0c,
0xc1, 0x2d, 0xf1, 0x4e, 0xe1, 0x6f, 0x10, 0x80, 0x00, 0xa1, 0x30, 0xc2,
0x20, 0xe3, 0x50, 0x04, 0x40, 0x25, 0x70, 0x46, 0x60, 0x67, 0x83, 0xb9,
0x93, 0x98, 0xa3, 0xfb, 0xb3, 0xda, 0xc3, 0x3d, 0xd3, 0x1c, 0xe3, 0x7f,
0xf3, 0x5e, 0x02, 0xb1, 0x12, 0x90, 0x22, 0xf3, 0x32, 0xd2, 0x42, 0x35,
0x52, 0x14, 0x62, 0x77, 0x72, 0x56, 0xb5, 0xea, 0xa5, 0xcb, 0x95, 0xa8,
0x85, 0x89, 0xf5, 0x6e, 0xe5, 0x4f, 0xd5, 0x2c, 0xc5, 0x0d, 0x34, 0xe2,
0x24, 0xc3, 0x14, 0xa0, 0x04, 0x81, 0x74, 0x66, 0x64, 0x47, 0x54, 0x24,
0x44, 0x05, 0xa7, 0xdb, 0xb7, 0xfa, 0x87, 0x99, 0x97, 0xb8, 0xe7, 0x5f,
0xf7, 0x7e, 0xc7, 0x1d, 0xd7, 0x3c, 0x26, 0xd3, 0x36, 0xf2, 0x06, 0x91,
0x16, 0xb0, 0x66, 0x57, 0x76, 0x76, 0x46, 0x15, 0x56, 0x34, 0xd9, 0x4c,
0xc9, 0x6d, 0xf9, 0x0e, 0xe9, 0x2f, 0x99, 0xc8, 0x89, 0xe9, 0xb9, 0x8a,
0xa9, 0xab, 0x58, 0x44, 0x48, 0x65, 0x78, 0x06, 0x68, 0x27, 0x18, 0xc0,
0x08, 0xe1, 0x38, 0x82, 0x28, 0xa3, 0xcb, 0x7d, 0xdb, 0x5c, 0xeb, 0x3f,
0xfb, 0x1e, 0x8b, 0xf9, 0x9b, 0xd8, 0xab, 0xbb, 0xbb, 0x9a, 0x4a, 0x75,
0x5a, 0x54, 0x6a, 0x37, 0x7a, 0x16, 0x0a, 0xf1, 0x1a, 0xd0, 0x2a, 0xb3,
0x3a, 0x92, 0xfd, 0x2e, 0xed, 0x0f, 0xdd, 0x6c, 0xcd, 0x4d, 0xbd, 0xaa,
0xad, 0x8b, 0x9d, 0xe8, 0x8d, 0xc9, 0x7c, 0x26, 0x6c, 0x07, 0x5c, 0x64,
0x4c, 0x45, 0x3c, 0xa2, 0x2c, 0x83, 0x1c, 0xe0, 0x0c, 0xc1, 0xef, 0x1f,
0xff, 0x3e, 0xcf, 0x5d, 0xdf, 0x7c, 0xaf, 0x9b, 0xbf, 0xba, 0x8f, 0xd9,
0x9f, 0xf8, 0x6e, 0x17, 0x7e, 0x36, 0x4e, 0x55, 0x5e, 0x74, 0x2e, 0x93,
0x3e, 0xb2, 0x0e, 0xd1, 0x1e, 0xf0, 0x1c, 0xa0, 0x1c, 0x18, 0x1b, 0x98,
0x1b, 0x18, 0x1a, 0x90, 0x1a, 0x10, 0x19, 0x88, 0x19, 0x08, 0x18, 0x80,
0x18, 0x00, 0x17, 0x80, 0x16, 0xf8, 0x16, 0x78, 0x15, 0xf0, 0x15, 0x70,
0x14, 0xe8, 0x14, 0x68, 0x13, 0xe8, 0x13, 0x60, 0x12, 0xe0, 0x12, 0x58,
0x00, 0x00, 0x00, 0x09, 0x00, 0x13, 0x00, 0x1c, 0x00, 0x26, 0x00, 0x2f,
0x00, 0x38, 0x00, 0x42, 0x00, 0x4b, 0x00, 0x54, 0x00, 0x5e, 0x00, 0x67,
0x00, 0x71, 0x00, 0x7a, 0x00, 0x83, 0x00, 0x8d, 0x00, 0x96, 0x00, 0x9f,
0x00, 0xa9, 0x00, 0xb2, 0x00, 0xbc, 0x00, 0xc5, 0x00, 0xce, 0x00, 0xe1,
0x00, 0xf4, 0x01, 0x07, 0x01, 0x19, 0x01, 0x2c, 0x01, 0x3f, 0x01, 0x52,
0x01, 0x64, 0x01, 0x77, 0x00, 0x00, 0x00, 0x10, 0x00, 0x1f, 0x00, 0x2f,
0x00, 0x3f, 0x00, 0x4e, 0x00, 0x5e, 0x00, 0x6d, 0x00, 0x7d, 0x00, 0x8d,
0x00, 0x9c, 0x00, 0xac, 0x00, 0xbc, 0x00, 0xcb, 0x00, 0xdb, 0x00, 0xea,
0x00, 0xfa, 0x01, 0x0a, 0x01, 0x19, 0x01, 0x29, 0x01, 0x39, 0x01, 0x48,
0x01, 0x58, 0x01, 0x77, 0x01, 0x96, 0x01, 0xb6, 0x01, 0xd5, 0x01, 0xf4,
0x02, 0x13, 0x02, 0x33, 0x02, 0x52, 0x02, 0x71, 0x1a, 0x1a, 0x1b, 0x1b,
0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x29, 0x2a, 0x2a, 0x15, 0x16, 0x16, 0x17, 0x17, 0x18, 0x18,
0x19, 0x19, 0x1a, 0x1a, 0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f,
0x1f, 0x20, 0x22, 0x23, 0x24, 0x25, 0x26, 0x26, 0x27, 0x27, 0x28, 0x28,
0x29, 0x29, 0x2a, 0x2a, 0x2b, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x21,
0x22, 0x23, 0x23, 0x24, 0x25, 0x26, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a,
0x2a, 0x2b, 0x2c, 0x2d, 0x2d, 0x2e, 0x2f, 0x2f, 0x00, 0x00, 0x00, 0xc0,
0x01, 0x80, 0x02, 0x40
};
|
the_stack_data/89683.c | #include <stdio.h>
int main()
{
float fahrenheit, celsius;
int start = -50, end = 300, by = 10;
fahrenheit = start;
while (fahrenheit <= end) {
celsius = (5.0/9.0) * (fahrenheit - 32);
printf("%3.0f°F = %5.1f°C\n", fahrenheit, celsius);
fahrenheit = fahrenheit + by;
}
}
/*
-50°F = -45.6°C
-40°F = -40.0°C
-30°F = -34.4°C
-20°F = -28.9°C
-10°F = -23.3°C
0°F = -17.8°C
10°F = -12.2°C
20°F = -6.7°C
30°F = -1.1°C
40°F = 4.4°C
50°F = 10.0°C
60°F = 15.6°C
70°F = 21.1°C
80°F = 26.7°C
90°F = 32.2°C
100°F = 37.8°C
110°F = 43.3°C
120°F = 48.9°C
130°F = 54.4°C
140°F = 60.0°C
150°F = 65.6°C
160°F = 71.1°C
170°F = 76.7°C
180°F = 82.2°C
190°F = 87.8°C
200°F = 93.3°C
210°F = 98.9°C
220°F = 104.4°C
230°F = 110.0°C
240°F = 115.6°C
250°F = 121.1°C
260°F = 126.7°C
270°F = 132.2°C
280°F = 137.8°C
290°F = 143.3°C
300°F = 148.9°C
*/
|
the_stack_data/852266.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int i = 1, m = 1, denda = 0, terlambat = 0;
int jt_tgl, jt_bln, jt_thn;
int menu, jumlah, kmbltgl, kmblbln, kmblthn, pnjmtgl, pnjmbln, pnjmthn, jumlah_peminjaman;
char nama_mmbr[20], alamat_mmbr[20], ttl_mmbr[2][10][4], pekerjaan_mmbr[20], kode[4][4], nama[20];
char jenis[5][100] = {"Pemrograman", "Sastra Jepang", "Teknologi", "Matematika", "Sains & physics"},
judul[5][100] = {"Trick for C++", "Katakana & Kanji 2", "Cisco Networking", "Statistika jilid 2", "Anatomi Tubuh Manusia"};
char ulang[10];
char member[10];
//tampilan menu
do
{
system("color 7D");
printf("----------------------------------------------------------------\n");
printf("| Syarat Dan Ketentuan: |");
printf("\n----------------------------------------------------------------\n");
printf("| 1. Diharap Mengisi Data Peminjaman Buku |\n");
printf("| 2. Apabila Terlambat Mengembalikan Buku Akan Dikenakan Denda |\n");
printf("----------------------------------------------------------------\n");
printf("\n======================================\n");
printf("| Selamat Datang Di Menu |\n");
printf("======================================\n");
printf("=============Perpustakaan=============\n");
printf("| 1. Buat Kartu Perpustakaan |\n");
printf("| 2. cek member |\n");
printf("| 3. Pinjam Buku |\n");
printf("| 4. Exit |\n");
printf("======================================\n");
printf("\n");
printf("Silahkan masukkan nomor pada menu...\n");
scanf("%d", &menu);
fflush(stdin);
/*Membersihkan Layar*/
system("cls");
system("color f0");
if (menu == 1)
{
printf("========================================\n");
printf("| ***Create a New Member*** |\n");
printf("========================================\n");
printf("Nama : ");
scanf("%[^\n]s", &nama_mmbr);
fflush(stdin);
printf("\nAlamat : ");
scanf("%[^\n]s", &alamat_mmbr);
fflush(stdin);
printf("\nTTL : ");
scanf("%[^\n]s", &ttl_mmbr);
fflush(stdin);
printf("\nPekerjaan : ");
scanf("%[^\n]s", &pekerjaan_mmbr);
fflush(stdin);
system("cls");
FILE *datamember = fopen("data_member.txt", "a");
fprintf(datamember, "%s#%s#%s#%s#%d\n", nama_mmbr, alamat_mmbr, ttl_mmbr, pekerjaan_mmbr, m);
fclose(datamember);
printf("Sukses menambah data member.");
getchar();
system("cls");
printf("=============================================\n");
printf("|==== * Card Member Perpustakaan Kita * ====|\n");
printf("=============================================");
printf("\n| Nama : %s ", nama_mmbr);
printf("\n| Alamat : %s ", alamat_mmbr);
printf("\n| TTL : %s ", ttl_mmbr);
printf("\n| Pekerjaan : %s ", pekerjaan_mmbr);
printf("\n=============================================\n");
printf("|* Terimakasih %s Telah Bergabung *|\n", nama_mmbr);
printf("=============================================\n");
}
system("color a");
if (menu == 2)
{
FILE *in = fopen("data_member.txt", "r");
if (!in)
{
printf("tidak ada file");
}
else
{
int i = 0;
while (!feof(in))
{
fscanf(in, "%[^#]#%[^#]#%[^#]#%s\n", &nama_mmbr, &alamat_mmbr, &ttl_mmbr, &pekerjaan_mmbr);
fflush(stdin);
printf("%d. Nama : %s", i + 1, nama_mmbr);
printf("\n Alamat : %s", alamat_mmbr);
printf("\n TTL : %s", ttl_mmbr);
printf("\n Pekerjaan : %s\n\n", pekerjaan_mmbr);
i++;
}
fclose(in);
printf("JUMLAH MEMBER : %d\n", i);
}
}
if (menu == 3)
{
printf("===============================================================\n");
printf("= =\n");
printf("= DAFTAR BUKU PERPUSTAKAAN =\n");
printf("= =\n");
printf("===============================================================\n\n");
printf("---------------------------------------------------------------\n");
printf("| KODE BUKU | JENIS BUKU | JUDUL BUKU |\n");
printf("---------------------------------------------------------------\n");
printf("| A1 | Pemrograman | Trick for C |\n");
printf("| A2 | Sastra Jepang | Katakana & Kanji 2 |\n");
printf("| A3 | Teknologi | Cisco Networking |\n");
printf("| A4 | Matematika | Statistika Jilid 2 |\n");
printf("| A5 | Sains & physics | Anatomi Tubuh Manusia |\n");
printf("---------------------------------------------------------------\n\n");
printf("Nama Penyewa Buku : ");
scanf("%[^\n]s", &nama);
do
{
printf("Jumlah Peminjaman : ");
scanf("%d", &jumlah_peminjaman);
if ((jumlah_peminjaman > 5) || (jumlah_peminjaman < 1))
{
printf("Jumlah Peminjaman Maximal 5\n");
}
} while ((jumlah_peminjaman > 5) || (jumlah_peminjaman < 1));
if ((jumlah_peminjaman <= 5) && (jumlah_peminjaman >= 1))
{
while (i <= jumlah_peminjaman)
{
printf("\n=======================================\n");
printf("| buku ke-%d \n", i);
printf("| Kode Buku : ");
scanf("%s", &kode[i]);
printf("| Jumlah Buku Yang Dipinjam : ");
scanf("%d", &jumlah);
printf("=======================================\n");
i++;
}
}
//input tanggal pinjam
printf("\nTanggal Pinjam\n");
while (1)
{
printf("Tanggal [DD] : ");
scanf("%d", &pnjmtgl);
if (pnjmtgl < 1 || pnjmtgl > 31)
{
printf("masukan ulang data..\n");
}
else
{
break;
}
}
while (1)
{
printf("Bulan [MM] : ");
scanf("%d", &pnjmbln);
if (pnjmbln < 1 || pnjmbln > 12)
{
printf("masukan ulang data..\n");
}
else
{
break;
}
}
while (1)
{
printf("Tahun [YYYY] : ");
scanf("%d", &pnjmthn);
if (pnjmthn < 1)
{
printf("masukan ulang data..\n");
}
else
{
break;
}
}
//input tanggal kembali
printf("\nTanggal Kembali\n");
while (1)
{
printf("Tanggal [DD] : ");
scanf("%d", &kmbltgl);
if (kmbltgl < 1 || kmbltgl > 31)
{
printf("masukan ulang data..\n");
}
else
{
break;
}
}
while (1)
{
printf("Bulan [MM] : ");
scanf("%d", &kmblbln);
if (kmblbln < 1 || kmblbln > 12)
{
printf("masukan ulang data..\n");
}
else
{
break;
}
}
while (1)
{
printf("Tahun [YYYY] : ");
scanf("%d", &kmblthn);
if (kmblthn < 1)
{
printf("masukan ulang data..\n");
}
else
{
break;
}
}
system("cls");
system("color 0");
//proses perhitungan denda
int lamaPinjam = (kmbltgl - pnjmtgl) + ((kmblbln - pnjmbln) * 30) + ((kmblthn - pnjmthn) * 360);
int terlambat = lamaPinjam - 7;
if (lamaPinjam > 7)
{
denda = terlambat * 1000;
}
else if (terlambat <= 7)
{
terlambat = 0;
}
printf("\nApakah Anda Punya Member ? (y/n)");
scanf("%s", &member);
if (strcmp(member, "y") == 0)
{
denda = terlambat * 500;
}
//perhitungan jatuh tempo pengembalian
jt_tgl = pnjmtgl + 7;
jt_bln = pnjmbln + (jt_tgl / 30);
jt_thn = pnjmthn + (jt_bln / 12);
if (jt_tgl > 30)
{
jt_tgl -= 30;
}
if (jt_bln > 12)
{
jt_bln -= 12;
}
system("color D");
printf("\nNama Penyewa Buku : %s", nama);
printf("\nJumlah Buku : %d\n\n", jumlah_peminjaman);
printf("-----------------------------------------------------------------\n");
printf("| KODE BUKU | JENIS BUKU | JUDUL BUKU | JUMLAH BUKU|\n");
printf("-----------------------------------------------------------------\n");
int i = 1;
if (jumlah_peminjaman > 0)
{
while (i <= jumlah_peminjaman)
{
printf(" %s %s %s %d \n\n", kode[i], jenis[i], judul[i], jumlah);
i++;
}
}
printf("\n Tanggal Pinjam : %d - %d - %d", pnjmtgl, pnjmbln, pnjmthn);
printf("\n Tanggal Kembali : %d - %d - %d", kmbltgl, kmblbln, kmblthn);
printf("\n Tanggal Jatuh tempo : %d - %d - %d", jt_tgl, jt_bln, jt_thn);
printf("\n Lama Peminjaman : %d hari", lamaPinjam);
printf("\n Lama Keterlambatan : %d hari", terlambat);
printf("\n Denda : Rp. %d", denda);
printf("\n\n\n\t\t*****TERIMAKASIH %s ATAS KUNJUNGAN ANDA!***** \n", nama);
}
if (menu == 4)
{
// getch();
}
//mengulang program
printf("\n\n--------------------------------\n");
printf(" Apakah ingin mengulang ? (y/n)");
printf("\n--------------------------------\n");
scanf("%s", &ulang);
system("cls");
} while (strcmp(ulang, "y") == 0);
return 0;
}
|
the_stack_data/184514197.c | /*
* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* Jeroen Domburg <[email protected]> wrote this file. As long as you retain
* this notice you can do whatever you want with this stuff. If we meet some day,
* and you think this stuff is worth it, you can buy me a beer in return.
* ----------------------------------------------------------------------------
*/
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
void hexdump (void *addr, int len) {
int i;
unsigned char buff[17];
unsigned char *pc = (unsigned char*)addr;
if (len == 0) {
printf(" ZERO LENGTH\n");
return;
}
if (len < 0) {
printf(" NEGATIVE LENGTH: %i\n",len);
return;
}
// Process every byte in the data.
for (i = 0; i < len; i++) {
// Multiple of 16 means new line (with line offset).
if ((i % 16) == 0) {
// Just don't print ASCII for the zeroth line.
if (i != 0)
printf (" %s\n", buff);
// Output the offset.
printf (" %04x ", i);
}
// Now the hex code for the specific character.
printf (" %02x", pc[i]);
// And store a printable ASCII character for later.
if ((pc[i] < 0x20) || (pc[i] > 0x7e))
buff[i % 16] = '.';
else
buff[i % 16] = pc[i];
buff[(i % 16) + 1] = '\0';
}
// Pad out last line if not exactly 16 characters.
while ((i % 16) != 0) {
printf (" ");
i++;
}
// And print the final ASCII bit.
printf (" %s\n", buff);
}
|
the_stack_data/916244.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nshelly <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/15 20:00:00 by nshelly #+# #+# */
/* Updated: 2019/04/24 13:46:14 by nshelly ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isascii(int c)
{
if (c >= 0 && c <= 127)
return (1);
return (0);
}
|
the_stack_data/323975.c | void pccheb(double d[], double c[], int n)
{
int j,jm,jp,k;
double fac,pow;
pow=1.0;
c[0]=2.0*d[0];
for (k=1;k<n;k++) {
c[k]=0.0;
fac=d[k]/pow;
jm=k;
jp=1;
for (j=k;j>=0;j-=2,jm--,jp++) {
c[j] += fac;
fac *= ((double)jm)/((double)jp);
}
pow += pow;
}
}
/* (C) Copr. 1986-92 Numerical Recipes Software 9.1-5i. */
|
the_stack_data/175141893.c | #include <stdio.h>
#include <string.h>
/* Нашел ошибку. Почему то функция strcmp мне выдала
неправильный результат в одном из случаев */
int main()
{
int n=0, i=0, j=0,k=0,x=0,y=0,max=-1,length=0, matrix[10][10];
char s[10][100];
scanf("%d", &n);
for (i=0; i<n; i++)
{
scanf("%s", s[i]);
length+=strnlen(s[i],1000);
}
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
matrix[i][j]=prefix(s[i], s[j]);
}
for (i=1; i<n; i++)
{
for (j=0; j<n; j++)
for (k=0; k<n; k++)
{
if (matrix[j][k]> max)
{
max= matrix[j][k];
x=j; y=k;
}
}
for (j=0; j<n; j++)
{
matrix[j][j]=0;
matrix[x][j]=0;
matrix[j][y]=0;
}
length-=max;
max=0;
}
printf("%d", length);
return 0;
}
int prefix( char *s1, char *s2)
{
int k=0, max=-1,i=0,j=0,lengths1=strnlen(s1,1000), lengths2=strnlen(s2,1000);
if (strcmp(s1, s2) == 0) return 0;
else if (lengths1>lengths2)
{
for (i=0; i<lengths2; i++)
{
for (j=0; j<lengths2-i; j++)
{
if (s1[lengths1-lengths2+i+j]==s2[j]) k++;
else
{
k=0;
break;
}
}
if (k>max) max=k;
k=0;
}
return max;
}
else
{
for (i=0; i<lengths1; i++)
{
for (j=0; j<lengths1-i; j++)
if (s1[i+j]==s2[j]) k++;
else
{
k=0;
break;
}
if (k>max) max=k;
k=0;
}
return max;
}
} |
the_stack_data/117328904.c | #include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main()
{
int network_socket;
network_socket=socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in server_address;
server_address.sin_family = AF_INET;
server_address.sin_port = htons(9002);
server_address.sin_addr.s_addr = INADDR_ANY;
int connection_status = connect(network_socket,(struct sockaddr*)&server_address,sizeof(server_address));
if(connection_status==-1)
printf("[-] Error in connecting to the server!\n");
else
printf("\n[+] Successfully connected to the remote server.");
char client_message[200];
printf("\n[$] Type 'yes' to receive the time: ");
scanf("%s",client_message);
send(network_socket,client_message,sizeof(client_message),0);
char server_response[100];
recv(network_socket,server_response,sizeof(server_response),0);
printf("\n%s\n",server_response);
close(network_socket);
return 0;
}
|
the_stack_data/86076112.c | #include <stdio.h>
#include <stdlib.h>
void dma_one_d(){
// Allocate memory to store five characters
int n = 5;
char *pvowels = (char *) malloc(n * sizeof(char));
int i;
pvowels[0] = 'A';
pvowels[1] = 'E';
*(pvowels + 2) = 'I';
pvowels[3] = 'O';
*(pvowels + 4) = 'U';
/*
As you can see, when using pvowels[2] and *(pvowels + 2) we are accessing the same thing
*/
for (i = 0; i < n; i++) {
printf("%c ", pvowels[i]);
}
printf("\n");
free(pvowels);
/*
When using Dynamic Memory Allocation, remember that we are responsible for freeing
the data at the pointer otherwise there are going to be memory leaks.
*/
}
void dma_two_d(){
int nrows = 2;
int ncols = 5;
int i, j;
// Allocate memory for nrows pointers
char **pvowels = (char **) malloc(nrows * sizeof(char *));
// For each row, allocate memory for ncols elements
pvowels[0] = (char *) malloc(ncols * sizeof(char));
pvowels[1] = (char *) malloc(ncols * sizeof(char));
pvowels[0][0] = 'A';
pvowels[0][1] = 'E';
pvowels[0][2] = 'I';
pvowels[0][3] = 'O';
pvowels[0][4] = 'U';
pvowels[1][0] = 'a';
pvowels[1][1] = 'e';
pvowels[1][2] = 'i';
pvowels[1][3] = 'o';
pvowels[1][4] = 'u';
for (i = 0; i < nrows; i++)
{
for (j = 0; j < ncols; j++)
{
printf("%c | ", pvowels[i][j]);
}
printf("\n");
}
// Free individual rows
free(pvowels[0]);
free(pvowels[1]);
// Free the top-level pointer
free(pvowels);
}
int main(){
char vowels[] = {'A', 'E', 'I', 'O', 'U'};
char *pvowels = vowels;
int i;
// Print the addresses
for (i = 0; i < 5; i++){
printf("&vowels[%d]: %p, pvowels + %d: %p, vowels + %d: %p\n", i, &vowels[i], i, pvowels + i, i, vowels + i);
}
// Print the values
for (i = 0; i < 5; i++){
printf("vowels[%d]: %c, *(pvowels + %d): %c, *(vowels + %d): %c\n", i, vowels[i], i, *(pvowels + i), i, *(vowels + i));
}
/* This shows 2 things:
1) &vowels[i] gives the memory address of the i'th element of the array
2) vowels, &vowels[0], and vowels + 0 all point to the same location, the first index of the array
(2) is because the name of the array itself is a constant pointer to the first element
of the array
*/
dma_one_d();
dma_two_d();
return 0;
} |
the_stack_data/237641894.c | #include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
/*
* COPYRIGHT
*
* b2d.c
* Copyright (C) 2013 Exstrom Laboratories LLC
*
* 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 2 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.
*
* A copy of the GNU General Public License is available on the internet at:
* http://www.gnu.org/copyleft/gpl.html
*
* or you can write to:
*
* The Free Software Foundation, Inc.
* 675 Mass Ave
* Cambridge, MA 02139, USA
*
* Exstrom Laboratories LLC contact:
* stefan(AT)exstrom.com
*
* Exstrom Laboratories LLC
* Longmont, CO 80503, USA
*
*/
/* Compile: gcc -lm -o b2d b2d.c */
/* Converts binary number to decimal. */
/* usage: b2d n */
int main( int argc, char *argv[] )
{
if(argc < 2) exit(-1);
int i, l = strlen(argv[1]);
unsigned long n = 0;
for(i=0; i<l; ++i) if(argv[1][i]=='1') n += 1 << (l - 1 - i);
printf("%lu\n", n);
return(0);
}
|
the_stack_data/89199530.c | // { "stdout": "Hello, world!" }
#include <stdio.h>
int main(void) {
if (fputs("Hello, world!", stdout) == 0) {
return ferror(stdout);
}
return 0;
}
|
the_stack_data/24392.c | // Check the -msign-return-address= option, which has a required argument to
// select scope.
// RUN: %clang -target aarch64--none-eabi -c %s -### -msign-return-address=none 2>&1 | \
// RUN: FileCheck %s --check-prefix=RA-OFF --check-prefix=KEY-A --check-prefix=BTE-OFF
// RUN: %clang -target aarch64--none-eabi -c %s -### -msign-return-address=non-leaf 2>&1 | \
// RUN: FileCheck %s --check-prefix=RA-NON-LEAF --check-prefix=KEY-A --check-prefix=BTE-OFF
// RUN: %clang -target aarch64--none-eabi -c %s -### -msign-return-address=all 2>&1 | \
// RUN: FileCheck %s --check-prefix=RA-ALL --check-prefix=KEY-A --check-prefix=BTE-OFF
// Check that the -msign-return-address= option can also accept the signing key
// to use.
// RUN: %clang -target aarch64--none-eabi -c %s -### -msign-return-address=non-leaf 2>&1 | \
// RUN: FileCheck %s --check-prefix=RA-NON-LEAF --check-prefix=KEY-B --check-prefix=BTE-OFF
// RUN: %clang -target aarch64--none-eabi -c %s -### -msign-return-address=all 2>&1 | \
// RUN: FileCheck %s --check-prefix=RA-ALL --check-prefix=KEY-B --check-prefix=BTE-OFF
// -mbranch-protection with standard
// RUN: %clang -target aarch64--none-eabi -c %s -### -mbranch-protection=standard 2>&1 | \
// RUN: FileCheck %s --check-prefix=RA-NON-LEAF --check-prefix=KEY-A --check-prefix=BTE-ON
// If the -msign-return-address and -mbranch-protection are both used, the
// right-most one controls return address signing.
// RUN: %clang -target aarch64--none-eabi -c %s -### -msign-return-address=non-leaf -mbranch-protection=none 2>&1 | \
// RUN: FileCheck %s --check-prefix=CONFLICT
// RUN: %clang -target aarch64--none-eabi -c %s -### -mbranch-protection=pac-ret -msign-return-address=none 2>&1 | \
// RUN: FileCheck %s --check-prefix=CONFLICT
// RUN: %clang -target aarch64--none-eabi -c %s -### -msign-return-address=foo 2>&1 | \
// RUN: FileCheck %s --check-prefix=BAD-RA-PROTECTION
// RUN: %clang -target aarch64--none-eabi -c %s -### -mbranch-protection=bar 2>&1 | \
// RUN: FileCheck %s --check-prefix=BAD-BP-PROTECTION
// RA-OFF: "-msign-return-address=none"
// RA-NON-LEAF: "-msign-return-address=non-leaf"
// RA-ALL: "-msign-return-address=all"
// KEY-A: "-msign-return-address-key=a_key"
// BTE-OFF-NOT: "-mbranch-target-enforce"
// BTE-ON: "-mbranch-target-enforce"
// CONFLICT: "-msign-return-address=none"
// BAD-RA-PROTECTION: invalid branch protection option 'foo' in '-msign-return-address={{.*}}'
// BAD-BP-PROTECTION: invalid branch protection option 'bar' in '-mbranch-protection={{.*}}'
// BAD-B-KEY-COMBINATION: invalid branch protection option 'b-key' in '-mbranch-protection={{.*}}'
// BAD-LEAF-COMBINATION: invalid branch protection option 'leaf' in '-mbranch-protection={{.*}}'
|
the_stack_data/59512337.c | /* Basic Bit Operations */
// =================================================================
// Libraries
#include<stdio.h>
// Main Function
void main()
{
int num = 5; // 101
printf("Number before shifting: %d", num);
num = num << 2; // 10100
printf("Number after shifting: %d", num);
}
// =================================================================
/* Code by Abel Roy */
|
the_stack_data/95914.c | #ifdef __APPLE__
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif
int main()
{
cl_uint platformIdCount;
// We can't assert on the result because this may return an error if no ICD
// is
// found
clGetPlatformIDs(0, NULL, &platformIdCount);
return 0;
}
|
the_stack_data/156393896.c |
#include <stdio.h>
#include <stdlib.h>
void scilab_rt_graduate_i0i0d0d0_d0i0d0(int scalarin0,
int scalarin1,
double scalarin2,
double scalarin3,
double* scalarout0,
int* scalarout1,
double* scalarout2)
{
printf("%d", scalarin0);
printf("%d", scalarin1);
printf("%f", scalarin2);
printf("%f", scalarin3);
*scalarout0 = rand();
*scalarout1 = rand();
*scalarout2 = rand();
}
|
the_stack_data/132953056.c | #include <stdio.h>
#include <stdlib.h>
int main(){
float n1,n2,n3,n4;
printf("Digite o 1 valor :");
scanf("%f",&n1);
printf("Digite o 2 valor :");
scanf("%f",&n2);
printf("Digite o 3 valor :");
scanf("%f",&n3);
printf("Digite o 3 valor :");
scanf("%f",&n4);
printf("\nMedia aritmetica:%.2f\n\n", (n1+n2+n3+n4)/4);
system("PAUSE");
return 0;
}
|
the_stack_data/64200135.c |
//
// This file is autogenerated.
//
void cross1(float* r0)
{
r0[0] = -1;
}
void cross2(const float* v0, float *r0)
{
r0[0] = -v0[1];
r0[1] = +v0[0];
}
void cross3(const float* v0, const float* v1, float *r0)
{
r0[0] = (v0[1] * v1[2]) + (-1 * v0[2] * v1[1]);
r0[1] = (-1 * v0[0] * v1[2]) + (v0[2] * v1[0]);
r0[2] = (v0[0] * v1[1]) + (-1 * v0[1] * v1[0]);
}
void cross4(const float* v0, const float* v1, const float* v2, float *r0)
{
r0[0] = (-1 * v0[1] * v1[2] * v2[3]) + (v0[1] * v1[3] * v2[2]) + (v0[2] * v1[1] * v2[3]) + (-1 * v0[2] * v1[3] * v2[1]) + (-1 * v0[3] * v1[1] * v2[2]) + (v0[3] * v1[2] * v2[1]);
r0[1] = (v0[0] * v1[2] * v2[3]) + (-1 * v0[0] * v1[3] * v2[2]) + (-1 * v0[2] * v1[0] * v2[3]) + (v0[2] * v1[3] * v2[0]) + (v0[3] * v1[0] * v2[2]) + (-1 * v0[3] * v1[2] * v2[0]);
r0[2] = (-1 * v0[0] * v1[1] * v2[3]) + (v0[0] * v1[3] * v2[1]) + (v0[1] * v1[0] * v2[3]) + (-1 * v0[1] * v1[3] * v2[0]) + (-1 * v0[3] * v1[0] * v2[1]) + (v0[3] * v1[1] * v2[0]);
r0[3] = (v0[0] * v1[1] * v2[2]) + (-1 * v0[0] * v1[2] * v2[1]) + (-1 * v0[1] * v1[0] * v2[2]) + (v0[1] * v1[2] * v2[0]) + (v0[2] * v1[0] * v2[1]) + (-1 * v0[2] * v1[1] * v2[0]);
}
void cross5(const float* v0, const float* v1, const float* v2, const float* v3, float *r0)
{
r0[0] = (v0[1] * v1[2] * v2[3] * v3[4]) + (-1 * v0[1] * v1[2] * v2[4] * v3[3]) + (-1 * v0[1] * v1[3] * v2[2] * v3[4]) + (v0[1] * v1[3] * v2[4] * v3[2]) + (v0[1] * v1[4] * v2[2] * v3[3]) + (-1 * v0[1] * v1[4] * v2[3] * v3[2]) + (-1 * v0[2] * v1[1] * v2[3] * v3[4]) + (v0[2] * v1[1] * v2[4] * v3[3]) + (v0[2] * v1[3] * v2[1] * v3[4]) + (-1 * v0[2] * v1[3] * v2[4] * v3[1]) + (-1 * v0[2] * v1[4] * v2[1] * v3[3]) + (v0[2] * v1[4] * v2[3] * v3[1]) + (v0[3] * v1[1] * v2[2] * v3[4]) + (-1 * v0[3] * v1[1] * v2[4] * v3[2]) + (-1 * v0[3] * v1[2] * v2[1] * v3[4]) + (v0[3] * v1[2] * v2[4] * v3[1]) + (v0[3] * v1[4] * v2[1] * v3[2]) + (-1 * v0[3] * v1[4] * v2[2] * v3[1]) + (-1 * v0[4] * v1[1] * v2[2] * v3[3]) + (v0[4] * v1[1] * v2[3] * v3[2]) + (v0[4] * v1[2] * v2[1] * v3[3]) + (-1 * v0[4] * v1[2] * v2[3] * v3[1]) + (-1 * v0[4] * v1[3] * v2[1] * v3[2]) + (v0[4] * v1[3] * v2[2] * v3[1]);
r0[1] = (-1 * v0[0] * v1[2] * v2[3] * v3[4]) + (v0[0] * v1[2] * v2[4] * v3[3]) + (v0[0] * v1[3] * v2[2] * v3[4]) + (-1 * v0[0] * v1[3] * v2[4] * v3[2]) + (-1 * v0[0] * v1[4] * v2[2] * v3[3]) + (v0[0] * v1[4] * v2[3] * v3[2]) + (v0[2] * v1[0] * v2[3] * v3[4]) + (-1 * v0[2] * v1[0] * v2[4] * v3[3]) + (-1 * v0[2] * v1[3] * v2[0] * v3[4]) + (v0[2] * v1[3] * v2[4] * v3[0]) + (v0[2] * v1[4] * v2[0] * v3[3]) + (-1 * v0[2] * v1[4] * v2[3] * v3[0]) + (-1 * v0[3] * v1[0] * v2[2] * v3[4]) + (v0[3] * v1[0] * v2[4] * v3[2]) + (v0[3] * v1[2] * v2[0] * v3[4]) + (-1 * v0[3] * v1[2] * v2[4] * v3[0]) + (-1 * v0[3] * v1[4] * v2[0] * v3[2]) + (v0[3] * v1[4] * v2[2] * v3[0]) + (v0[4] * v1[0] * v2[2] * v3[3]) + (-1 * v0[4] * v1[0] * v2[3] * v3[2]) + (-1 * v0[4] * v1[2] * v2[0] * v3[3]) + (v0[4] * v1[2] * v2[3] * v3[0]) + (v0[4] * v1[3] * v2[0] * v3[2]) + (-1 * v0[4] * v1[3] * v2[2] * v3[0]);
r0[2] = (v0[0] * v1[1] * v2[3] * v3[4]) + (-1 * v0[0] * v1[1] * v2[4] * v3[3]) + (-1 * v0[0] * v1[3] * v2[1] * v3[4]) + (v0[0] * v1[3] * v2[4] * v3[1]) + (v0[0] * v1[4] * v2[1] * v3[3]) + (-1 * v0[0] * v1[4] * v2[3] * v3[1]) + (-1 * v0[1] * v1[0] * v2[3] * v3[4]) + (v0[1] * v1[0] * v2[4] * v3[3]) + (v0[1] * v1[3] * v2[0] * v3[4]) + (-1 * v0[1] * v1[3] * v2[4] * v3[0]) + (-1 * v0[1] * v1[4] * v2[0] * v3[3]) + (v0[1] * v1[4] * v2[3] * v3[0]) + (v0[3] * v1[0] * v2[1] * v3[4]) + (-1 * v0[3] * v1[0] * v2[4] * v3[1]) + (-1 * v0[3] * v1[1] * v2[0] * v3[4]) + (v0[3] * v1[1] * v2[4] * v3[0]) + (v0[3] * v1[4] * v2[0] * v3[1]) + (-1 * v0[3] * v1[4] * v2[1] * v3[0]) + (-1 * v0[4] * v1[0] * v2[1] * v3[3]) + (v0[4] * v1[0] * v2[3] * v3[1]) + (v0[4] * v1[1] * v2[0] * v3[3]) + (-1 * v0[4] * v1[1] * v2[3] * v3[0]) + (-1 * v0[4] * v1[3] * v2[0] * v3[1]) + (v0[4] * v1[3] * v2[1] * v3[0]);
r0[3] = (-1 * v0[0] * v1[1] * v2[2] * v3[4]) + (v0[0] * v1[1] * v2[4] * v3[2]) + (v0[0] * v1[2] * v2[1] * v3[4]) + (-1 * v0[0] * v1[2] * v2[4] * v3[1]) + (-1 * v0[0] * v1[4] * v2[1] * v3[2]) + (v0[0] * v1[4] * v2[2] * v3[1]) + (v0[1] * v1[0] * v2[2] * v3[4]) + (-1 * v0[1] * v1[0] * v2[4] * v3[2]) + (-1 * v0[1] * v1[2] * v2[0] * v3[4]) + (v0[1] * v1[2] * v2[4] * v3[0]) + (v0[1] * v1[4] * v2[0] * v3[2]) + (-1 * v0[1] * v1[4] * v2[2] * v3[0]) + (-1 * v0[2] * v1[0] * v2[1] * v3[4]) + (v0[2] * v1[0] * v2[4] * v3[1]) + (v0[2] * v1[1] * v2[0] * v3[4]) + (-1 * v0[2] * v1[1] * v2[4] * v3[0]) + (-1 * v0[2] * v1[4] * v2[0] * v3[1]) + (v0[2] * v1[4] * v2[1] * v3[0]) + (v0[4] * v1[0] * v2[1] * v3[2]) + (-1 * v0[4] * v1[0] * v2[2] * v3[1]) + (-1 * v0[4] * v1[1] * v2[0] * v3[2]) + (v0[4] * v1[1] * v2[2] * v3[0]) + (v0[4] * v1[2] * v2[0] * v3[1]) + (-1 * v0[4] * v1[2] * v2[1] * v3[0]);
r0[4] = (v0[0] * v1[1] * v2[2] * v3[3]) + (-1 * v0[0] * v1[1] * v2[3] * v3[2]) + (-1 * v0[0] * v1[2] * v2[1] * v3[3]) + (v0[0] * v1[2] * v2[3] * v3[1]) + (v0[0] * v1[3] * v2[1] * v3[2]) + (-1 * v0[0] * v1[3] * v2[2] * v3[1]) + (-1 * v0[1] * v1[0] * v2[2] * v3[3]) + (v0[1] * v1[0] * v2[3] * v3[2]) + (v0[1] * v1[2] * v2[0] * v3[3]) + (-1 * v0[1] * v1[2] * v2[3] * v3[0]) + (-1 * v0[1] * v1[3] * v2[0] * v3[2]) + (v0[1] * v1[3] * v2[2] * v3[0]) + (v0[2] * v1[0] * v2[1] * v3[3]) + (-1 * v0[2] * v1[0] * v2[3] * v3[1]) + (-1 * v0[2] * v1[1] * v2[0] * v3[3]) + (v0[2] * v1[1] * v2[3] * v3[0]) + (v0[2] * v1[3] * v2[0] * v3[1]) + (-1 * v0[2] * v1[3] * v2[1] * v3[0]) + (-1 * v0[3] * v1[0] * v2[1] * v3[2]) + (v0[3] * v1[0] * v2[2] * v3[1]) + (v0[3] * v1[1] * v2[0] * v3[2]) + (-1 * v0[3] * v1[1] * v2[2] * v3[0]) + (-1 * v0[3] * v1[2] * v2[0] * v3[1]) + (v0[3] * v1[2] * v2[1] * v3[0]);
}
void cross6(const float* v0, const float* v1, const float* v2, const float* v3, const float* v4, float *r0)
{
r0[0] = (-1 * v0[1] * v1[2] * v2[3] * v3[4] * v4[5]) + (v0[1] * v1[2] * v2[3] * v3[5] * v4[4]) + (v0[1] * v1[2] * v2[4] * v3[3] * v4[5]) + (-1 * v0[1] * v1[2] * v2[4] * v3[5] * v4[3]) + (-1 * v0[1] * v1[2] * v2[5] * v3[3] * v4[4]) + (v0[1] * v1[2] * v2[5] * v3[4] * v4[3]) + (v0[1] * v1[3] * v2[2] * v3[4] * v4[5]) + (-1 * v0[1] * v1[3] * v2[2] * v3[5] * v4[4]) + (-1 * v0[1] * v1[3] * v2[4] * v3[2] * v4[5]) + (v0[1] * v1[3] * v2[4] * v3[5] * v4[2]) + (v0[1] * v1[3] * v2[5] * v3[2] * v4[4]) + (-1 * v0[1] * v1[3] * v2[5] * v3[4] * v4[2]) + (-1 * v0[1] * v1[4] * v2[2] * v3[3] * v4[5]) + (v0[1] * v1[4] * v2[2] * v3[5] * v4[3]) + (v0[1] * v1[4] * v2[3] * v3[2] * v4[5]) + (-1 * v0[1] * v1[4] * v2[3] * v3[5] * v4[2]) + (-1 * v0[1] * v1[4] * v2[5] * v3[2] * v4[3]) + (v0[1] * v1[4] * v2[5] * v3[3] * v4[2]) + (v0[1] * v1[5] * v2[2] * v3[3] * v4[4]) + (-1 * v0[1] * v1[5] * v2[2] * v3[4] * v4[3]) + (-1 * v0[1] * v1[5] * v2[3] * v3[2] * v4[4]) + (v0[1] * v1[5] * v2[3] * v3[4] * v4[2]) + (v0[1] * v1[5] * v2[4] * v3[2] * v4[3]) + (-1 * v0[1] * v1[5] * v2[4] * v3[3] * v4[2]) + (v0[2] * v1[1] * v2[3] * v3[4] * v4[5]) + (-1 * v0[2] * v1[1] * v2[3] * v3[5] * v4[4]) + (-1 * v0[2] * v1[1] * v2[4] * v3[3] * v4[5]) + (v0[2] * v1[1] * v2[4] * v3[5] * v4[3]) + (v0[2] * v1[1] * v2[5] * v3[3] * v4[4]) + (-1 * v0[2] * v1[1] * v2[5] * v3[4] * v4[3]) + (-1 * v0[2] * v1[3] * v2[1] * v3[4] * v4[5]) + (v0[2] * v1[3] * v2[1] * v3[5] * v4[4]) + (v0[2] * v1[3] * v2[4] * v3[1] * v4[5]) + (-1 * v0[2] * v1[3] * v2[4] * v3[5] * v4[1]) + (-1 * v0[2] * v1[3] * v2[5] * v3[1] * v4[4]) + (v0[2] * v1[3] * v2[5] * v3[4] * v4[1]) + (v0[2] * v1[4] * v2[1] * v3[3] * v4[5]) + (-1 * v0[2] * v1[4] * v2[1] * v3[5] * v4[3]) + (-1 * v0[2] * v1[4] * v2[3] * v3[1] * v4[5]) + (v0[2] * v1[4] * v2[3] * v3[5] * v4[1]) + (v0[2] * v1[4] * v2[5] * v3[1] * v4[3]) + (-1 * v0[2] * v1[4] * v2[5] * v3[3] * v4[1]) + (-1 * v0[2] * v1[5] * v2[1] * v3[3] * v4[4]) + (v0[2] * v1[5] * v2[1] * v3[4] * v4[3]) + (v0[2] * v1[5] * v2[3] * v3[1] * v4[4]) + (-1 * v0[2] * v1[5] * v2[3] * v3[4] * v4[1]) + (-1 * v0[2] * v1[5] * v2[4] * v3[1] * v4[3]) + (v0[2] * v1[5] * v2[4] * v3[3] * v4[1]) + (-1 * v0[3] * v1[1] * v2[2] * v3[4] * v4[5]) + (v0[3] * v1[1] * v2[2] * v3[5] * v4[4]) + (v0[3] * v1[1] * v2[4] * v3[2] * v4[5]) + (-1 * v0[3] * v1[1] * v2[4] * v3[5] * v4[2]) + (-1 * v0[3] * v1[1] * v2[5] * v3[2] * v4[4]) + (v0[3] * v1[1] * v2[5] * v3[4] * v4[2]) + (v0[3] * v1[2] * v2[1] * v3[4] * v4[5]) + (-1 * v0[3] * v1[2] * v2[1] * v3[5] * v4[4]) + (-1 * v0[3] * v1[2] * v2[4] * v3[1] * v4[5]) + (v0[3] * v1[2] * v2[4] * v3[5] * v4[1]) + (v0[3] * v1[2] * v2[5] * v3[1] * v4[4]) + (-1 * v0[3] * v1[2] * v2[5] * v3[4] * v4[1]) + (-1 * v0[3] * v1[4] * v2[1] * v3[2] * v4[5]) + (v0[3] * v1[4] * v2[1] * v3[5] * v4[2]) + (v0[3] * v1[4] * v2[2] * v3[1] * v4[5]) + (-1 * v0[3] * v1[4] * v2[2] * v3[5] * v4[1]) + (-1 * v0[3] * v1[4] * v2[5] * v3[1] * v4[2]) + (v0[3] * v1[4] * v2[5] * v3[2] * v4[1]) + (v0[3] * v1[5] * v2[1] * v3[2] * v4[4]) + (-1 * v0[3] * v1[5] * v2[1] * v3[4] * v4[2]) + (-1 * v0[3] * v1[5] * v2[2] * v3[1] * v4[4]) + (v0[3] * v1[5] * v2[2] * v3[4] * v4[1]) + (v0[3] * v1[5] * v2[4] * v3[1] * v4[2]) + (-1 * v0[3] * v1[5] * v2[4] * v3[2] * v4[1]) + (v0[4] * v1[1] * v2[2] * v3[3] * v4[5]) + (-1 * v0[4] * v1[1] * v2[2] * v3[5] * v4[3]) + (-1 * v0[4] * v1[1] * v2[3] * v3[2] * v4[5]) + (v0[4] * v1[1] * v2[3] * v3[5] * v4[2]) + (v0[4] * v1[1] * v2[5] * v3[2] * v4[3]) + (-1 * v0[4] * v1[1] * v2[5] * v3[3] * v4[2]) + (-1 * v0[4] * v1[2] * v2[1] * v3[3] * v4[5]) + (v0[4] * v1[2] * v2[1] * v3[5] * v4[3]) + (v0[4] * v1[2] * v2[3] * v3[1] * v4[5]) + (-1 * v0[4] * v1[2] * v2[3] * v3[5] * v4[1]) + (-1 * v0[4] * v1[2] * v2[5] * v3[1] * v4[3]) + (v0[4] * v1[2] * v2[5] * v3[3] * v4[1]) + (v0[4] * v1[3] * v2[1] * v3[2] * v4[5]) + (-1 * v0[4] * v1[3] * v2[1] * v3[5] * v4[2]) + (-1 * v0[4] * v1[3] * v2[2] * v3[1] * v4[5]) + (v0[4] * v1[3] * v2[2] * v3[5] * v4[1]) + (v0[4] * v1[3] * v2[5] * v3[1] * v4[2]) + (-1 * v0[4] * v1[3] * v2[5] * v3[2] * v4[1]) + (-1 * v0[4] * v1[5] * v2[1] * v3[2] * v4[3]) + (v0[4] * v1[5] * v2[1] * v3[3] * v4[2]) + (v0[4] * v1[5] * v2[2] * v3[1] * v4[3]) + (-1 * v0[4] * v1[5] * v2[2] * v3[3] * v4[1]) + (-1 * v0[4] * v1[5] * v2[3] * v3[1] * v4[2]) + (v0[4] * v1[5] * v2[3] * v3[2] * v4[1]) + (-1 * v0[5] * v1[1] * v2[2] * v3[3] * v4[4]) + (v0[5] * v1[1] * v2[2] * v3[4] * v4[3]) + (v0[5] * v1[1] * v2[3] * v3[2] * v4[4]) + (-1 * v0[5] * v1[1] * v2[3] * v3[4] * v4[2]) + (-1 * v0[5] * v1[1] * v2[4] * v3[2] * v4[3]) + (v0[5] * v1[1] * v2[4] * v3[3] * v4[2]) + (v0[5] * v1[2] * v2[1] * v3[3] * v4[4]) + (-1 * v0[5] * v1[2] * v2[1] * v3[4] * v4[3]) + (-1 * v0[5] * v1[2] * v2[3] * v3[1] * v4[4]) + (v0[5] * v1[2] * v2[3] * v3[4] * v4[1]) + (v0[5] * v1[2] * v2[4] * v3[1] * v4[3]) + (-1 * v0[5] * v1[2] * v2[4] * v3[3] * v4[1]) + (-1 * v0[5] * v1[3] * v2[1] * v3[2] * v4[4]) + (v0[5] * v1[3] * v2[1] * v3[4] * v4[2]) + (v0[5] * v1[3] * v2[2] * v3[1] * v4[4]) + (-1 * v0[5] * v1[3] * v2[2] * v3[4] * v4[1]) + (-1 * v0[5] * v1[3] * v2[4] * v3[1] * v4[2]) + (v0[5] * v1[3] * v2[4] * v3[2] * v4[1]) + (v0[5] * v1[4] * v2[1] * v3[2] * v4[3]) + (-1 * v0[5] * v1[4] * v2[1] * v3[3] * v4[2]) + (-1 * v0[5] * v1[4] * v2[2] * v3[1] * v4[3]) + (v0[5] * v1[4] * v2[2] * v3[3] * v4[1]) + (v0[5] * v1[4] * v2[3] * v3[1] * v4[2]) + (-1 * v0[5] * v1[4] * v2[3] * v3[2] * v4[1]);
r0[1] = (v0[0] * v1[2] * v2[3] * v3[4] * v4[5]) + (-1 * v0[0] * v1[2] * v2[3] * v3[5] * v4[4]) + (-1 * v0[0] * v1[2] * v2[4] * v3[3] * v4[5]) + (v0[0] * v1[2] * v2[4] * v3[5] * v4[3]) + (v0[0] * v1[2] * v2[5] * v3[3] * v4[4]) + (-1 * v0[0] * v1[2] * v2[5] * v3[4] * v4[3]) + (-1 * v0[0] * v1[3] * v2[2] * v3[4] * v4[5]) + (v0[0] * v1[3] * v2[2] * v3[5] * v4[4]) + (v0[0] * v1[3] * v2[4] * v3[2] * v4[5]) + (-1 * v0[0] * v1[3] * v2[4] * v3[5] * v4[2]) + (-1 * v0[0] * v1[3] * v2[5] * v3[2] * v4[4]) + (v0[0] * v1[3] * v2[5] * v3[4] * v4[2]) + (v0[0] * v1[4] * v2[2] * v3[3] * v4[5]) + (-1 * v0[0] * v1[4] * v2[2] * v3[5] * v4[3]) + (-1 * v0[0] * v1[4] * v2[3] * v3[2] * v4[5]) + (v0[0] * v1[4] * v2[3] * v3[5] * v4[2]) + (v0[0] * v1[4] * v2[5] * v3[2] * v4[3]) + (-1 * v0[0] * v1[4] * v2[5] * v3[3] * v4[2]) + (-1 * v0[0] * v1[5] * v2[2] * v3[3] * v4[4]) + (v0[0] * v1[5] * v2[2] * v3[4] * v4[3]) + (v0[0] * v1[5] * v2[3] * v3[2] * v4[4]) + (-1 * v0[0] * v1[5] * v2[3] * v3[4] * v4[2]) + (-1 * v0[0] * v1[5] * v2[4] * v3[2] * v4[3]) + (v0[0] * v1[5] * v2[4] * v3[3] * v4[2]) + (-1 * v0[2] * v1[0] * v2[3] * v3[4] * v4[5]) + (v0[2] * v1[0] * v2[3] * v3[5] * v4[4]) + (v0[2] * v1[0] * v2[4] * v3[3] * v4[5]) + (-1 * v0[2] * v1[0] * v2[4] * v3[5] * v4[3]) + (-1 * v0[2] * v1[0] * v2[5] * v3[3] * v4[4]) + (v0[2] * v1[0] * v2[5] * v3[4] * v4[3]) + (v0[2] * v1[3] * v2[0] * v3[4] * v4[5]) + (-1 * v0[2] * v1[3] * v2[0] * v3[5] * v4[4]) + (-1 * v0[2] * v1[3] * v2[4] * v3[0] * v4[5]) + (v0[2] * v1[3] * v2[4] * v3[5] * v4[0]) + (v0[2] * v1[3] * v2[5] * v3[0] * v4[4]) + (-1 * v0[2] * v1[3] * v2[5] * v3[4] * v4[0]) + (-1 * v0[2] * v1[4] * v2[0] * v3[3] * v4[5]) + (v0[2] * v1[4] * v2[0] * v3[5] * v4[3]) + (v0[2] * v1[4] * v2[3] * v3[0] * v4[5]) + (-1 * v0[2] * v1[4] * v2[3] * v3[5] * v4[0]) + (-1 * v0[2] * v1[4] * v2[5] * v3[0] * v4[3]) + (v0[2] * v1[4] * v2[5] * v3[3] * v4[0]) + (v0[2] * v1[5] * v2[0] * v3[3] * v4[4]) + (-1 * v0[2] * v1[5] * v2[0] * v3[4] * v4[3]) + (-1 * v0[2] * v1[5] * v2[3] * v3[0] * v4[4]) + (v0[2] * v1[5] * v2[3] * v3[4] * v4[0]) + (v0[2] * v1[5] * v2[4] * v3[0] * v4[3]) + (-1 * v0[2] * v1[5] * v2[4] * v3[3] * v4[0]) + (v0[3] * v1[0] * v2[2] * v3[4] * v4[5]) + (-1 * v0[3] * v1[0] * v2[2] * v3[5] * v4[4]) + (-1 * v0[3] * v1[0] * v2[4] * v3[2] * v4[5]) + (v0[3] * v1[0] * v2[4] * v3[5] * v4[2]) + (v0[3] * v1[0] * v2[5] * v3[2] * v4[4]) + (-1 * v0[3] * v1[0] * v2[5] * v3[4] * v4[2]) + (-1 * v0[3] * v1[2] * v2[0] * v3[4] * v4[5]) + (v0[3] * v1[2] * v2[0] * v3[5] * v4[4]) + (v0[3] * v1[2] * v2[4] * v3[0] * v4[5]) + (-1 * v0[3] * v1[2] * v2[4] * v3[5] * v4[0]) + (-1 * v0[3] * v1[2] * v2[5] * v3[0] * v4[4]) + (v0[3] * v1[2] * v2[5] * v3[4] * v4[0]) + (v0[3] * v1[4] * v2[0] * v3[2] * v4[5]) + (-1 * v0[3] * v1[4] * v2[0] * v3[5] * v4[2]) + (-1 * v0[3] * v1[4] * v2[2] * v3[0] * v4[5]) + (v0[3] * v1[4] * v2[2] * v3[5] * v4[0]) + (v0[3] * v1[4] * v2[5] * v3[0] * v4[2]) + (-1 * v0[3] * v1[4] * v2[5] * v3[2] * v4[0]) + (-1 * v0[3] * v1[5] * v2[0] * v3[2] * v4[4]) + (v0[3] * v1[5] * v2[0] * v3[4] * v4[2]) + (v0[3] * v1[5] * v2[2] * v3[0] * v4[4]) + (-1 * v0[3] * v1[5] * v2[2] * v3[4] * v4[0]) + (-1 * v0[3] * v1[5] * v2[4] * v3[0] * v4[2]) + (v0[3] * v1[5] * v2[4] * v3[2] * v4[0]) + (-1 * v0[4] * v1[0] * v2[2] * v3[3] * v4[5]) + (v0[4] * v1[0] * v2[2] * v3[5] * v4[3]) + (v0[4] * v1[0] * v2[3] * v3[2] * v4[5]) + (-1 * v0[4] * v1[0] * v2[3] * v3[5] * v4[2]) + (-1 * v0[4] * v1[0] * v2[5] * v3[2] * v4[3]) + (v0[4] * v1[0] * v2[5] * v3[3] * v4[2]) + (v0[4] * v1[2] * v2[0] * v3[3] * v4[5]) + (-1 * v0[4] * v1[2] * v2[0] * v3[5] * v4[3]) + (-1 * v0[4] * v1[2] * v2[3] * v3[0] * v4[5]) + (v0[4] * v1[2] * v2[3] * v3[5] * v4[0]) + (v0[4] * v1[2] * v2[5] * v3[0] * v4[3]) + (-1 * v0[4] * v1[2] * v2[5] * v3[3] * v4[0]) + (-1 * v0[4] * v1[3] * v2[0] * v3[2] * v4[5]) + (v0[4] * v1[3] * v2[0] * v3[5] * v4[2]) + (v0[4] * v1[3] * v2[2] * v3[0] * v4[5]) + (-1 * v0[4] * v1[3] * v2[2] * v3[5] * v4[0]) + (-1 * v0[4] * v1[3] * v2[5] * v3[0] * v4[2]) + (v0[4] * v1[3] * v2[5] * v3[2] * v4[0]) + (v0[4] * v1[5] * v2[0] * v3[2] * v4[3]) + (-1 * v0[4] * v1[5] * v2[0] * v3[3] * v4[2]) + (-1 * v0[4] * v1[5] * v2[2] * v3[0] * v4[3]) + (v0[4] * v1[5] * v2[2] * v3[3] * v4[0]) + (v0[4] * v1[5] * v2[3] * v3[0] * v4[2]) + (-1 * v0[4] * v1[5] * v2[3] * v3[2] * v4[0]) + (v0[5] * v1[0] * v2[2] * v3[3] * v4[4]) + (-1 * v0[5] * v1[0] * v2[2] * v3[4] * v4[3]) + (-1 * v0[5] * v1[0] * v2[3] * v3[2] * v4[4]) + (v0[5] * v1[0] * v2[3] * v3[4] * v4[2]) + (v0[5] * v1[0] * v2[4] * v3[2] * v4[3]) + (-1 * v0[5] * v1[0] * v2[4] * v3[3] * v4[2]) + (-1 * v0[5] * v1[2] * v2[0] * v3[3] * v4[4]) + (v0[5] * v1[2] * v2[0] * v3[4] * v4[3]) + (v0[5] * v1[2] * v2[3] * v3[0] * v4[4]) + (-1 * v0[5] * v1[2] * v2[3] * v3[4] * v4[0]) + (-1 * v0[5] * v1[2] * v2[4] * v3[0] * v4[3]) + (v0[5] * v1[2] * v2[4] * v3[3] * v4[0]) + (v0[5] * v1[3] * v2[0] * v3[2] * v4[4]) + (-1 * v0[5] * v1[3] * v2[0] * v3[4] * v4[2]) + (-1 * v0[5] * v1[3] * v2[2] * v3[0] * v4[4]) + (v0[5] * v1[3] * v2[2] * v3[4] * v4[0]) + (v0[5] * v1[3] * v2[4] * v3[0] * v4[2]) + (-1 * v0[5] * v1[3] * v2[4] * v3[2] * v4[0]) + (-1 * v0[5] * v1[4] * v2[0] * v3[2] * v4[3]) + (v0[5] * v1[4] * v2[0] * v3[3] * v4[2]) + (v0[5] * v1[4] * v2[2] * v3[0] * v4[3]) + (-1 * v0[5] * v1[4] * v2[2] * v3[3] * v4[0]) + (-1 * v0[5] * v1[4] * v2[3] * v3[0] * v4[2]) + (v0[5] * v1[4] * v2[3] * v3[2] * v4[0]);
r0[2] = (-1 * v0[0] * v1[1] * v2[3] * v3[4] * v4[5]) + (v0[0] * v1[1] * v2[3] * v3[5] * v4[4]) + (v0[0] * v1[1] * v2[4] * v3[3] * v4[5]) + (-1 * v0[0] * v1[1] * v2[4] * v3[5] * v4[3]) + (-1 * v0[0] * v1[1] * v2[5] * v3[3] * v4[4]) + (v0[0] * v1[1] * v2[5] * v3[4] * v4[3]) + (v0[0] * v1[3] * v2[1] * v3[4] * v4[5]) + (-1 * v0[0] * v1[3] * v2[1] * v3[5] * v4[4]) + (-1 * v0[0] * v1[3] * v2[4] * v3[1] * v4[5]) + (v0[0] * v1[3] * v2[4] * v3[5] * v4[1]) + (v0[0] * v1[3] * v2[5] * v3[1] * v4[4]) + (-1 * v0[0] * v1[3] * v2[5] * v3[4] * v4[1]) + (-1 * v0[0] * v1[4] * v2[1] * v3[3] * v4[5]) + (v0[0] * v1[4] * v2[1] * v3[5] * v4[3]) + (v0[0] * v1[4] * v2[3] * v3[1] * v4[5]) + (-1 * v0[0] * v1[4] * v2[3] * v3[5] * v4[1]) + (-1 * v0[0] * v1[4] * v2[5] * v3[1] * v4[3]) + (v0[0] * v1[4] * v2[5] * v3[3] * v4[1]) + (v0[0] * v1[5] * v2[1] * v3[3] * v4[4]) + (-1 * v0[0] * v1[5] * v2[1] * v3[4] * v4[3]) + (-1 * v0[0] * v1[5] * v2[3] * v3[1] * v4[4]) + (v0[0] * v1[5] * v2[3] * v3[4] * v4[1]) + (v0[0] * v1[5] * v2[4] * v3[1] * v4[3]) + (-1 * v0[0] * v1[5] * v2[4] * v3[3] * v4[1]) + (v0[1] * v1[0] * v2[3] * v3[4] * v4[5]) + (-1 * v0[1] * v1[0] * v2[3] * v3[5] * v4[4]) + (-1 * v0[1] * v1[0] * v2[4] * v3[3] * v4[5]) + (v0[1] * v1[0] * v2[4] * v3[5] * v4[3]) + (v0[1] * v1[0] * v2[5] * v3[3] * v4[4]) + (-1 * v0[1] * v1[0] * v2[5] * v3[4] * v4[3]) + (-1 * v0[1] * v1[3] * v2[0] * v3[4] * v4[5]) + (v0[1] * v1[3] * v2[0] * v3[5] * v4[4]) + (v0[1] * v1[3] * v2[4] * v3[0] * v4[5]) + (-1 * v0[1] * v1[3] * v2[4] * v3[5] * v4[0]) + (-1 * v0[1] * v1[3] * v2[5] * v3[0] * v4[4]) + (v0[1] * v1[3] * v2[5] * v3[4] * v4[0]) + (v0[1] * v1[4] * v2[0] * v3[3] * v4[5]) + (-1 * v0[1] * v1[4] * v2[0] * v3[5] * v4[3]) + (-1 * v0[1] * v1[4] * v2[3] * v3[0] * v4[5]) + (v0[1] * v1[4] * v2[3] * v3[5] * v4[0]) + (v0[1] * v1[4] * v2[5] * v3[0] * v4[3]) + (-1 * v0[1] * v1[4] * v2[5] * v3[3] * v4[0]) + (-1 * v0[1] * v1[5] * v2[0] * v3[3] * v4[4]) + (v0[1] * v1[5] * v2[0] * v3[4] * v4[3]) + (v0[1] * v1[5] * v2[3] * v3[0] * v4[4]) + (-1 * v0[1] * v1[5] * v2[3] * v3[4] * v4[0]) + (-1 * v0[1] * v1[5] * v2[4] * v3[0] * v4[3]) + (v0[1] * v1[5] * v2[4] * v3[3] * v4[0]) + (-1 * v0[3] * v1[0] * v2[1] * v3[4] * v4[5]) + (v0[3] * v1[0] * v2[1] * v3[5] * v4[4]) + (v0[3] * v1[0] * v2[4] * v3[1] * v4[5]) + (-1 * v0[3] * v1[0] * v2[4] * v3[5] * v4[1]) + (-1 * v0[3] * v1[0] * v2[5] * v3[1] * v4[4]) + (v0[3] * v1[0] * v2[5] * v3[4] * v4[1]) + (v0[3] * v1[1] * v2[0] * v3[4] * v4[5]) + (-1 * v0[3] * v1[1] * v2[0] * v3[5] * v4[4]) + (-1 * v0[3] * v1[1] * v2[4] * v3[0] * v4[5]) + (v0[3] * v1[1] * v2[4] * v3[5] * v4[0]) + (v0[3] * v1[1] * v2[5] * v3[0] * v4[4]) + (-1 * v0[3] * v1[1] * v2[5] * v3[4] * v4[0]) + (-1 * v0[3] * v1[4] * v2[0] * v3[1] * v4[5]) + (v0[3] * v1[4] * v2[0] * v3[5] * v4[1]) + (v0[3] * v1[4] * v2[1] * v3[0] * v4[5]) + (-1 * v0[3] * v1[4] * v2[1] * v3[5] * v4[0]) + (-1 * v0[3] * v1[4] * v2[5] * v3[0] * v4[1]) + (v0[3] * v1[4] * v2[5] * v3[1] * v4[0]) + (v0[3] * v1[5] * v2[0] * v3[1] * v4[4]) + (-1 * v0[3] * v1[5] * v2[0] * v3[4] * v4[1]) + (-1 * v0[3] * v1[5] * v2[1] * v3[0] * v4[4]) + (v0[3] * v1[5] * v2[1] * v3[4] * v4[0]) + (v0[3] * v1[5] * v2[4] * v3[0] * v4[1]) + (-1 * v0[3] * v1[5] * v2[4] * v3[1] * v4[0]) + (v0[4] * v1[0] * v2[1] * v3[3] * v4[5]) + (-1 * v0[4] * v1[0] * v2[1] * v3[5] * v4[3]) + (-1 * v0[4] * v1[0] * v2[3] * v3[1] * v4[5]) + (v0[4] * v1[0] * v2[3] * v3[5] * v4[1]) + (v0[4] * v1[0] * v2[5] * v3[1] * v4[3]) + (-1 * v0[4] * v1[0] * v2[5] * v3[3] * v4[1]) + (-1 * v0[4] * v1[1] * v2[0] * v3[3] * v4[5]) + (v0[4] * v1[1] * v2[0] * v3[5] * v4[3]) + (v0[4] * v1[1] * v2[3] * v3[0] * v4[5]) + (-1 * v0[4] * v1[1] * v2[3] * v3[5] * v4[0]) + (-1 * v0[4] * v1[1] * v2[5] * v3[0] * v4[3]) + (v0[4] * v1[1] * v2[5] * v3[3] * v4[0]) + (v0[4] * v1[3] * v2[0] * v3[1] * v4[5]) + (-1 * v0[4] * v1[3] * v2[0] * v3[5] * v4[1]) + (-1 * v0[4] * v1[3] * v2[1] * v3[0] * v4[5]) + (v0[4] * v1[3] * v2[1] * v3[5] * v4[0]) + (v0[4] * v1[3] * v2[5] * v3[0] * v4[1]) + (-1 * v0[4] * v1[3] * v2[5] * v3[1] * v4[0]) + (-1 * v0[4] * v1[5] * v2[0] * v3[1] * v4[3]) + (v0[4] * v1[5] * v2[0] * v3[3] * v4[1]) + (v0[4] * v1[5] * v2[1] * v3[0] * v4[3]) + (-1 * v0[4] * v1[5] * v2[1] * v3[3] * v4[0]) + (-1 * v0[4] * v1[5] * v2[3] * v3[0] * v4[1]) + (v0[4] * v1[5] * v2[3] * v3[1] * v4[0]) + (-1 * v0[5] * v1[0] * v2[1] * v3[3] * v4[4]) + (v0[5] * v1[0] * v2[1] * v3[4] * v4[3]) + (v0[5] * v1[0] * v2[3] * v3[1] * v4[4]) + (-1 * v0[5] * v1[0] * v2[3] * v3[4] * v4[1]) + (-1 * v0[5] * v1[0] * v2[4] * v3[1] * v4[3]) + (v0[5] * v1[0] * v2[4] * v3[3] * v4[1]) + (v0[5] * v1[1] * v2[0] * v3[3] * v4[4]) + (-1 * v0[5] * v1[1] * v2[0] * v3[4] * v4[3]) + (-1 * v0[5] * v1[1] * v2[3] * v3[0] * v4[4]) + (v0[5] * v1[1] * v2[3] * v3[4] * v4[0]) + (v0[5] * v1[1] * v2[4] * v3[0] * v4[3]) + (-1 * v0[5] * v1[1] * v2[4] * v3[3] * v4[0]) + (-1 * v0[5] * v1[3] * v2[0] * v3[1] * v4[4]) + (v0[5] * v1[3] * v2[0] * v3[4] * v4[1]) + (v0[5] * v1[3] * v2[1] * v3[0] * v4[4]) + (-1 * v0[5] * v1[3] * v2[1] * v3[4] * v4[0]) + (-1 * v0[5] * v1[3] * v2[4] * v3[0] * v4[1]) + (v0[5] * v1[3] * v2[4] * v3[1] * v4[0]) + (v0[5] * v1[4] * v2[0] * v3[1] * v4[3]) + (-1 * v0[5] * v1[4] * v2[0] * v3[3] * v4[1]) + (-1 * v0[5] * v1[4] * v2[1] * v3[0] * v4[3]) + (v0[5] * v1[4] * v2[1] * v3[3] * v4[0]) + (v0[5] * v1[4] * v2[3] * v3[0] * v4[1]) + (-1 * v0[5] * v1[4] * v2[3] * v3[1] * v4[0]);
r0[3] = (v0[0] * v1[1] * v2[2] * v3[4] * v4[5]) + (-1 * v0[0] * v1[1] * v2[2] * v3[5] * v4[4]) + (-1 * v0[0] * v1[1] * v2[4] * v3[2] * v4[5]) + (v0[0] * v1[1] * v2[4] * v3[5] * v4[2]) + (v0[0] * v1[1] * v2[5] * v3[2] * v4[4]) + (-1 * v0[0] * v1[1] * v2[5] * v3[4] * v4[2]) + (-1 * v0[0] * v1[2] * v2[1] * v3[4] * v4[5]) + (v0[0] * v1[2] * v2[1] * v3[5] * v4[4]) + (v0[0] * v1[2] * v2[4] * v3[1] * v4[5]) + (-1 * v0[0] * v1[2] * v2[4] * v3[5] * v4[1]) + (-1 * v0[0] * v1[2] * v2[5] * v3[1] * v4[4]) + (v0[0] * v1[2] * v2[5] * v3[4] * v4[1]) + (v0[0] * v1[4] * v2[1] * v3[2] * v4[5]) + (-1 * v0[0] * v1[4] * v2[1] * v3[5] * v4[2]) + (-1 * v0[0] * v1[4] * v2[2] * v3[1] * v4[5]) + (v0[0] * v1[4] * v2[2] * v3[5] * v4[1]) + (v0[0] * v1[4] * v2[5] * v3[1] * v4[2]) + (-1 * v0[0] * v1[4] * v2[5] * v3[2] * v4[1]) + (-1 * v0[0] * v1[5] * v2[1] * v3[2] * v4[4]) + (v0[0] * v1[5] * v2[1] * v3[4] * v4[2]) + (v0[0] * v1[5] * v2[2] * v3[1] * v4[4]) + (-1 * v0[0] * v1[5] * v2[2] * v3[4] * v4[1]) + (-1 * v0[0] * v1[5] * v2[4] * v3[1] * v4[2]) + (v0[0] * v1[5] * v2[4] * v3[2] * v4[1]) + (-1 * v0[1] * v1[0] * v2[2] * v3[4] * v4[5]) + (v0[1] * v1[0] * v2[2] * v3[5] * v4[4]) + (v0[1] * v1[0] * v2[4] * v3[2] * v4[5]) + (-1 * v0[1] * v1[0] * v2[4] * v3[5] * v4[2]) + (-1 * v0[1] * v1[0] * v2[5] * v3[2] * v4[4]) + (v0[1] * v1[0] * v2[5] * v3[4] * v4[2]) + (v0[1] * v1[2] * v2[0] * v3[4] * v4[5]) + (-1 * v0[1] * v1[2] * v2[0] * v3[5] * v4[4]) + (-1 * v0[1] * v1[2] * v2[4] * v3[0] * v4[5]) + (v0[1] * v1[2] * v2[4] * v3[5] * v4[0]) + (v0[1] * v1[2] * v2[5] * v3[0] * v4[4]) + (-1 * v0[1] * v1[2] * v2[5] * v3[4] * v4[0]) + (-1 * v0[1] * v1[4] * v2[0] * v3[2] * v4[5]) + (v0[1] * v1[4] * v2[0] * v3[5] * v4[2]) + (v0[1] * v1[4] * v2[2] * v3[0] * v4[5]) + (-1 * v0[1] * v1[4] * v2[2] * v3[5] * v4[0]) + (-1 * v0[1] * v1[4] * v2[5] * v3[0] * v4[2]) + (v0[1] * v1[4] * v2[5] * v3[2] * v4[0]) + (v0[1] * v1[5] * v2[0] * v3[2] * v4[4]) + (-1 * v0[1] * v1[5] * v2[0] * v3[4] * v4[2]) + (-1 * v0[1] * v1[5] * v2[2] * v3[0] * v4[4]) + (v0[1] * v1[5] * v2[2] * v3[4] * v4[0]) + (v0[1] * v1[5] * v2[4] * v3[0] * v4[2]) + (-1 * v0[1] * v1[5] * v2[4] * v3[2] * v4[0]) + (v0[2] * v1[0] * v2[1] * v3[4] * v4[5]) + (-1 * v0[2] * v1[0] * v2[1] * v3[5] * v4[4]) + (-1 * v0[2] * v1[0] * v2[4] * v3[1] * v4[5]) + (v0[2] * v1[0] * v2[4] * v3[5] * v4[1]) + (v0[2] * v1[0] * v2[5] * v3[1] * v4[4]) + (-1 * v0[2] * v1[0] * v2[5] * v3[4] * v4[1]) + (-1 * v0[2] * v1[1] * v2[0] * v3[4] * v4[5]) + (v0[2] * v1[1] * v2[0] * v3[5] * v4[4]) + (v0[2] * v1[1] * v2[4] * v3[0] * v4[5]) + (-1 * v0[2] * v1[1] * v2[4] * v3[5] * v4[0]) + (-1 * v0[2] * v1[1] * v2[5] * v3[0] * v4[4]) + (v0[2] * v1[1] * v2[5] * v3[4] * v4[0]) + (v0[2] * v1[4] * v2[0] * v3[1] * v4[5]) + (-1 * v0[2] * v1[4] * v2[0] * v3[5] * v4[1]) + (-1 * v0[2] * v1[4] * v2[1] * v3[0] * v4[5]) + (v0[2] * v1[4] * v2[1] * v3[5] * v4[0]) + (v0[2] * v1[4] * v2[5] * v3[0] * v4[1]) + (-1 * v0[2] * v1[4] * v2[5] * v3[1] * v4[0]) + (-1 * v0[2] * v1[5] * v2[0] * v3[1] * v4[4]) + (v0[2] * v1[5] * v2[0] * v3[4] * v4[1]) + (v0[2] * v1[5] * v2[1] * v3[0] * v4[4]) + (-1 * v0[2] * v1[5] * v2[1] * v3[4] * v4[0]) + (-1 * v0[2] * v1[5] * v2[4] * v3[0] * v4[1]) + (v0[2] * v1[5] * v2[4] * v3[1] * v4[0]) + (-1 * v0[4] * v1[0] * v2[1] * v3[2] * v4[5]) + (v0[4] * v1[0] * v2[1] * v3[5] * v4[2]) + (v0[4] * v1[0] * v2[2] * v3[1] * v4[5]) + (-1 * v0[4] * v1[0] * v2[2] * v3[5] * v4[1]) + (-1 * v0[4] * v1[0] * v2[5] * v3[1] * v4[2]) + (v0[4] * v1[0] * v2[5] * v3[2] * v4[1]) + (v0[4] * v1[1] * v2[0] * v3[2] * v4[5]) + (-1 * v0[4] * v1[1] * v2[0] * v3[5] * v4[2]) + (-1 * v0[4] * v1[1] * v2[2] * v3[0] * v4[5]) + (v0[4] * v1[1] * v2[2] * v3[5] * v4[0]) + (v0[4] * v1[1] * v2[5] * v3[0] * v4[2]) + (-1 * v0[4] * v1[1] * v2[5] * v3[2] * v4[0]) + (-1 * v0[4] * v1[2] * v2[0] * v3[1] * v4[5]) + (v0[4] * v1[2] * v2[0] * v3[5] * v4[1]) + (v0[4] * v1[2] * v2[1] * v3[0] * v4[5]) + (-1 * v0[4] * v1[2] * v2[1] * v3[5] * v4[0]) + (-1 * v0[4] * v1[2] * v2[5] * v3[0] * v4[1]) + (v0[4] * v1[2] * v2[5] * v3[1] * v4[0]) + (v0[4] * v1[5] * v2[0] * v3[1] * v4[2]) + (-1 * v0[4] * v1[5] * v2[0] * v3[2] * v4[1]) + (-1 * v0[4] * v1[5] * v2[1] * v3[0] * v4[2]) + (v0[4] * v1[5] * v2[1] * v3[2] * v4[0]) + (v0[4] * v1[5] * v2[2] * v3[0] * v4[1]) + (-1 * v0[4] * v1[5] * v2[2] * v3[1] * v4[0]) + (v0[5] * v1[0] * v2[1] * v3[2] * v4[4]) + (-1 * v0[5] * v1[0] * v2[1] * v3[4] * v4[2]) + (-1 * v0[5] * v1[0] * v2[2] * v3[1] * v4[4]) + (v0[5] * v1[0] * v2[2] * v3[4] * v4[1]) + (v0[5] * v1[0] * v2[4] * v3[1] * v4[2]) + (-1 * v0[5] * v1[0] * v2[4] * v3[2] * v4[1]) + (-1 * v0[5] * v1[1] * v2[0] * v3[2] * v4[4]) + (v0[5] * v1[1] * v2[0] * v3[4] * v4[2]) + (v0[5] * v1[1] * v2[2] * v3[0] * v4[4]) + (-1 * v0[5] * v1[1] * v2[2] * v3[4] * v4[0]) + (-1 * v0[5] * v1[1] * v2[4] * v3[0] * v4[2]) + (v0[5] * v1[1] * v2[4] * v3[2] * v4[0]) + (v0[5] * v1[2] * v2[0] * v3[1] * v4[4]) + (-1 * v0[5] * v1[2] * v2[0] * v3[4] * v4[1]) + (-1 * v0[5] * v1[2] * v2[1] * v3[0] * v4[4]) + (v0[5] * v1[2] * v2[1] * v3[4] * v4[0]) + (v0[5] * v1[2] * v2[4] * v3[0] * v4[1]) + (-1 * v0[5] * v1[2] * v2[4] * v3[1] * v4[0]) + (-1 * v0[5] * v1[4] * v2[0] * v3[1] * v4[2]) + (v0[5] * v1[4] * v2[0] * v3[2] * v4[1]) + (v0[5] * v1[4] * v2[1] * v3[0] * v4[2]) + (-1 * v0[5] * v1[4] * v2[1] * v3[2] * v4[0]) + (-1 * v0[5] * v1[4] * v2[2] * v3[0] * v4[1]) + (v0[5] * v1[4] * v2[2] * v3[1] * v4[0]);
r0[4] = (-1 * v0[0] * v1[1] * v2[2] * v3[3] * v4[5]) + (v0[0] * v1[1] * v2[2] * v3[5] * v4[3]) + (v0[0] * v1[1] * v2[3] * v3[2] * v4[5]) + (-1 * v0[0] * v1[1] * v2[3] * v3[5] * v4[2]) + (-1 * v0[0] * v1[1] * v2[5] * v3[2] * v4[3]) + (v0[0] * v1[1] * v2[5] * v3[3] * v4[2]) + (v0[0] * v1[2] * v2[1] * v3[3] * v4[5]) + (-1 * v0[0] * v1[2] * v2[1] * v3[5] * v4[3]) + (-1 * v0[0] * v1[2] * v2[3] * v3[1] * v4[5]) + (v0[0] * v1[2] * v2[3] * v3[5] * v4[1]) + (v0[0] * v1[2] * v2[5] * v3[1] * v4[3]) + (-1 * v0[0] * v1[2] * v2[5] * v3[3] * v4[1]) + (-1 * v0[0] * v1[3] * v2[1] * v3[2] * v4[5]) + (v0[0] * v1[3] * v2[1] * v3[5] * v4[2]) + (v0[0] * v1[3] * v2[2] * v3[1] * v4[5]) + (-1 * v0[0] * v1[3] * v2[2] * v3[5] * v4[1]) + (-1 * v0[0] * v1[3] * v2[5] * v3[1] * v4[2]) + (v0[0] * v1[3] * v2[5] * v3[2] * v4[1]) + (v0[0] * v1[5] * v2[1] * v3[2] * v4[3]) + (-1 * v0[0] * v1[5] * v2[1] * v3[3] * v4[2]) + (-1 * v0[0] * v1[5] * v2[2] * v3[1] * v4[3]) + (v0[0] * v1[5] * v2[2] * v3[3] * v4[1]) + (v0[0] * v1[5] * v2[3] * v3[1] * v4[2]) + (-1 * v0[0] * v1[5] * v2[3] * v3[2] * v4[1]) + (v0[1] * v1[0] * v2[2] * v3[3] * v4[5]) + (-1 * v0[1] * v1[0] * v2[2] * v3[5] * v4[3]) + (-1 * v0[1] * v1[0] * v2[3] * v3[2] * v4[5]) + (v0[1] * v1[0] * v2[3] * v3[5] * v4[2]) + (v0[1] * v1[0] * v2[5] * v3[2] * v4[3]) + (-1 * v0[1] * v1[0] * v2[5] * v3[3] * v4[2]) + (-1 * v0[1] * v1[2] * v2[0] * v3[3] * v4[5]) + (v0[1] * v1[2] * v2[0] * v3[5] * v4[3]) + (v0[1] * v1[2] * v2[3] * v3[0] * v4[5]) + (-1 * v0[1] * v1[2] * v2[3] * v3[5] * v4[0]) + (-1 * v0[1] * v1[2] * v2[5] * v3[0] * v4[3]) + (v0[1] * v1[2] * v2[5] * v3[3] * v4[0]) + (v0[1] * v1[3] * v2[0] * v3[2] * v4[5]) + (-1 * v0[1] * v1[3] * v2[0] * v3[5] * v4[2]) + (-1 * v0[1] * v1[3] * v2[2] * v3[0] * v4[5]) + (v0[1] * v1[3] * v2[2] * v3[5] * v4[0]) + (v0[1] * v1[3] * v2[5] * v3[0] * v4[2]) + (-1 * v0[1] * v1[3] * v2[5] * v3[2] * v4[0]) + (-1 * v0[1] * v1[5] * v2[0] * v3[2] * v4[3]) + (v0[1] * v1[5] * v2[0] * v3[3] * v4[2]) + (v0[1] * v1[5] * v2[2] * v3[0] * v4[3]) + (-1 * v0[1] * v1[5] * v2[2] * v3[3] * v4[0]) + (-1 * v0[1] * v1[5] * v2[3] * v3[0] * v4[2]) + (v0[1] * v1[5] * v2[3] * v3[2] * v4[0]) + (-1 * v0[2] * v1[0] * v2[1] * v3[3] * v4[5]) + (v0[2] * v1[0] * v2[1] * v3[5] * v4[3]) + (v0[2] * v1[0] * v2[3] * v3[1] * v4[5]) + (-1 * v0[2] * v1[0] * v2[3] * v3[5] * v4[1]) + (-1 * v0[2] * v1[0] * v2[5] * v3[1] * v4[3]) + (v0[2] * v1[0] * v2[5] * v3[3] * v4[1]) + (v0[2] * v1[1] * v2[0] * v3[3] * v4[5]) + (-1 * v0[2] * v1[1] * v2[0] * v3[5] * v4[3]) + (-1 * v0[2] * v1[1] * v2[3] * v3[0] * v4[5]) + (v0[2] * v1[1] * v2[3] * v3[5] * v4[0]) + (v0[2] * v1[1] * v2[5] * v3[0] * v4[3]) + (-1 * v0[2] * v1[1] * v2[5] * v3[3] * v4[0]) + (-1 * v0[2] * v1[3] * v2[0] * v3[1] * v4[5]) + (v0[2] * v1[3] * v2[0] * v3[5] * v4[1]) + (v0[2] * v1[3] * v2[1] * v3[0] * v4[5]) + (-1 * v0[2] * v1[3] * v2[1] * v3[5] * v4[0]) + (-1 * v0[2] * v1[3] * v2[5] * v3[0] * v4[1]) + (v0[2] * v1[3] * v2[5] * v3[1] * v4[0]) + (v0[2] * v1[5] * v2[0] * v3[1] * v4[3]) + (-1 * v0[2] * v1[5] * v2[0] * v3[3] * v4[1]) + (-1 * v0[2] * v1[5] * v2[1] * v3[0] * v4[3]) + (v0[2] * v1[5] * v2[1] * v3[3] * v4[0]) + (v0[2] * v1[5] * v2[3] * v3[0] * v4[1]) + (-1 * v0[2] * v1[5] * v2[3] * v3[1] * v4[0]) + (v0[3] * v1[0] * v2[1] * v3[2] * v4[5]) + (-1 * v0[3] * v1[0] * v2[1] * v3[5] * v4[2]) + (-1 * v0[3] * v1[0] * v2[2] * v3[1] * v4[5]) + (v0[3] * v1[0] * v2[2] * v3[5] * v4[1]) + (v0[3] * v1[0] * v2[5] * v3[1] * v4[2]) + (-1 * v0[3] * v1[0] * v2[5] * v3[2] * v4[1]) + (-1 * v0[3] * v1[1] * v2[0] * v3[2] * v4[5]) + (v0[3] * v1[1] * v2[0] * v3[5] * v4[2]) + (v0[3] * v1[1] * v2[2] * v3[0] * v4[5]) + (-1 * v0[3] * v1[1] * v2[2] * v3[5] * v4[0]) + (-1 * v0[3] * v1[1] * v2[5] * v3[0] * v4[2]) + (v0[3] * v1[1] * v2[5] * v3[2] * v4[0]) + (v0[3] * v1[2] * v2[0] * v3[1] * v4[5]) + (-1 * v0[3] * v1[2] * v2[0] * v3[5] * v4[1]) + (-1 * v0[3] * v1[2] * v2[1] * v3[0] * v4[5]) + (v0[3] * v1[2] * v2[1] * v3[5] * v4[0]) + (v0[3] * v1[2] * v2[5] * v3[0] * v4[1]) + (-1 * v0[3] * v1[2] * v2[5] * v3[1] * v4[0]) + (-1 * v0[3] * v1[5] * v2[0] * v3[1] * v4[2]) + (v0[3] * v1[5] * v2[0] * v3[2] * v4[1]) + (v0[3] * v1[5] * v2[1] * v3[0] * v4[2]) + (-1 * v0[3] * v1[5] * v2[1] * v3[2] * v4[0]) + (-1 * v0[3] * v1[5] * v2[2] * v3[0] * v4[1]) + (v0[3] * v1[5] * v2[2] * v3[1] * v4[0]) + (-1 * v0[5] * v1[0] * v2[1] * v3[2] * v4[3]) + (v0[5] * v1[0] * v2[1] * v3[3] * v4[2]) + (v0[5] * v1[0] * v2[2] * v3[1] * v4[3]) + (-1 * v0[5] * v1[0] * v2[2] * v3[3] * v4[1]) + (-1 * v0[5] * v1[0] * v2[3] * v3[1] * v4[2]) + (v0[5] * v1[0] * v2[3] * v3[2] * v4[1]) + (v0[5] * v1[1] * v2[0] * v3[2] * v4[3]) + (-1 * v0[5] * v1[1] * v2[0] * v3[3] * v4[2]) + (-1 * v0[5] * v1[1] * v2[2] * v3[0] * v4[3]) + (v0[5] * v1[1] * v2[2] * v3[3] * v4[0]) + (v0[5] * v1[1] * v2[3] * v3[0] * v4[2]) + (-1 * v0[5] * v1[1] * v2[3] * v3[2] * v4[0]) + (-1 * v0[5] * v1[2] * v2[0] * v3[1] * v4[3]) + (v0[5] * v1[2] * v2[0] * v3[3] * v4[1]) + (v0[5] * v1[2] * v2[1] * v3[0] * v4[3]) + (-1 * v0[5] * v1[2] * v2[1] * v3[3] * v4[0]) + (-1 * v0[5] * v1[2] * v2[3] * v3[0] * v4[1]) + (v0[5] * v1[2] * v2[3] * v3[1] * v4[0]) + (v0[5] * v1[3] * v2[0] * v3[1] * v4[2]) + (-1 * v0[5] * v1[3] * v2[0] * v3[2] * v4[1]) + (-1 * v0[5] * v1[3] * v2[1] * v3[0] * v4[2]) + (v0[5] * v1[3] * v2[1] * v3[2] * v4[0]) + (v0[5] * v1[3] * v2[2] * v3[0] * v4[1]) + (-1 * v0[5] * v1[3] * v2[2] * v3[1] * v4[0]);
r0[5] = (v0[0] * v1[1] * v2[2] * v3[3] * v4[4]) + (-1 * v0[0] * v1[1] * v2[2] * v3[4] * v4[3]) + (-1 * v0[0] * v1[1] * v2[3] * v3[2] * v4[4]) + (v0[0] * v1[1] * v2[3] * v3[4] * v4[2]) + (v0[0] * v1[1] * v2[4] * v3[2] * v4[3]) + (-1 * v0[0] * v1[1] * v2[4] * v3[3] * v4[2]) + (-1 * v0[0] * v1[2] * v2[1] * v3[3] * v4[4]) + (v0[0] * v1[2] * v2[1] * v3[4] * v4[3]) + (v0[0] * v1[2] * v2[3] * v3[1] * v4[4]) + (-1 * v0[0] * v1[2] * v2[3] * v3[4] * v4[1]) + (-1 * v0[0] * v1[2] * v2[4] * v3[1] * v4[3]) + (v0[0] * v1[2] * v2[4] * v3[3] * v4[1]) + (v0[0] * v1[3] * v2[1] * v3[2] * v4[4]) + (-1 * v0[0] * v1[3] * v2[1] * v3[4] * v4[2]) + (-1 * v0[0] * v1[3] * v2[2] * v3[1] * v4[4]) + (v0[0] * v1[3] * v2[2] * v3[4] * v4[1]) + (v0[0] * v1[3] * v2[4] * v3[1] * v4[2]) + (-1 * v0[0] * v1[3] * v2[4] * v3[2] * v4[1]) + (-1 * v0[0] * v1[4] * v2[1] * v3[2] * v4[3]) + (v0[0] * v1[4] * v2[1] * v3[3] * v4[2]) + (v0[0] * v1[4] * v2[2] * v3[1] * v4[3]) + (-1 * v0[0] * v1[4] * v2[2] * v3[3] * v4[1]) + (-1 * v0[0] * v1[4] * v2[3] * v3[1] * v4[2]) + (v0[0] * v1[4] * v2[3] * v3[2] * v4[1]) + (-1 * v0[1] * v1[0] * v2[2] * v3[3] * v4[4]) + (v0[1] * v1[0] * v2[2] * v3[4] * v4[3]) + (v0[1] * v1[0] * v2[3] * v3[2] * v4[4]) + (-1 * v0[1] * v1[0] * v2[3] * v3[4] * v4[2]) + (-1 * v0[1] * v1[0] * v2[4] * v3[2] * v4[3]) + (v0[1] * v1[0] * v2[4] * v3[3] * v4[2]) + (v0[1] * v1[2] * v2[0] * v3[3] * v4[4]) + (-1 * v0[1] * v1[2] * v2[0] * v3[4] * v4[3]) + (-1 * v0[1] * v1[2] * v2[3] * v3[0] * v4[4]) + (v0[1] * v1[2] * v2[3] * v3[4] * v4[0]) + (v0[1] * v1[2] * v2[4] * v3[0] * v4[3]) + (-1 * v0[1] * v1[2] * v2[4] * v3[3] * v4[0]) + (-1 * v0[1] * v1[3] * v2[0] * v3[2] * v4[4]) + (v0[1] * v1[3] * v2[0] * v3[4] * v4[2]) + (v0[1] * v1[3] * v2[2] * v3[0] * v4[4]) + (-1 * v0[1] * v1[3] * v2[2] * v3[4] * v4[0]) + (-1 * v0[1] * v1[3] * v2[4] * v3[0] * v4[2]) + (v0[1] * v1[3] * v2[4] * v3[2] * v4[0]) + (v0[1] * v1[4] * v2[0] * v3[2] * v4[3]) + (-1 * v0[1] * v1[4] * v2[0] * v3[3] * v4[2]) + (-1 * v0[1] * v1[4] * v2[2] * v3[0] * v4[3]) + (v0[1] * v1[4] * v2[2] * v3[3] * v4[0]) + (v0[1] * v1[4] * v2[3] * v3[0] * v4[2]) + (-1 * v0[1] * v1[4] * v2[3] * v3[2] * v4[0]) + (v0[2] * v1[0] * v2[1] * v3[3] * v4[4]) + (-1 * v0[2] * v1[0] * v2[1] * v3[4] * v4[3]) + (-1 * v0[2] * v1[0] * v2[3] * v3[1] * v4[4]) + (v0[2] * v1[0] * v2[3] * v3[4] * v4[1]) + (v0[2] * v1[0] * v2[4] * v3[1] * v4[3]) + (-1 * v0[2] * v1[0] * v2[4] * v3[3] * v4[1]) + (-1 * v0[2] * v1[1] * v2[0] * v3[3] * v4[4]) + (v0[2] * v1[1] * v2[0] * v3[4] * v4[3]) + (v0[2] * v1[1] * v2[3] * v3[0] * v4[4]) + (-1 * v0[2] * v1[1] * v2[3] * v3[4] * v4[0]) + (-1 * v0[2] * v1[1] * v2[4] * v3[0] * v4[3]) + (v0[2] * v1[1] * v2[4] * v3[3] * v4[0]) + (v0[2] * v1[3] * v2[0] * v3[1] * v4[4]) + (-1 * v0[2] * v1[3] * v2[0] * v3[4] * v4[1]) + (-1 * v0[2] * v1[3] * v2[1] * v3[0] * v4[4]) + (v0[2] * v1[3] * v2[1] * v3[4] * v4[0]) + (v0[2] * v1[3] * v2[4] * v3[0] * v4[1]) + (-1 * v0[2] * v1[3] * v2[4] * v3[1] * v4[0]) + (-1 * v0[2] * v1[4] * v2[0] * v3[1] * v4[3]) + (v0[2] * v1[4] * v2[0] * v3[3] * v4[1]) + (v0[2] * v1[4] * v2[1] * v3[0] * v4[3]) + (-1 * v0[2] * v1[4] * v2[1] * v3[3] * v4[0]) + (-1 * v0[2] * v1[4] * v2[3] * v3[0] * v4[1]) + (v0[2] * v1[4] * v2[3] * v3[1] * v4[0]) + (-1 * v0[3] * v1[0] * v2[1] * v3[2] * v4[4]) + (v0[3] * v1[0] * v2[1] * v3[4] * v4[2]) + (v0[3] * v1[0] * v2[2] * v3[1] * v4[4]) + (-1 * v0[3] * v1[0] * v2[2] * v3[4] * v4[1]) + (-1 * v0[3] * v1[0] * v2[4] * v3[1] * v4[2]) + (v0[3] * v1[0] * v2[4] * v3[2] * v4[1]) + (v0[3] * v1[1] * v2[0] * v3[2] * v4[4]) + (-1 * v0[3] * v1[1] * v2[0] * v3[4] * v4[2]) + (-1 * v0[3] * v1[1] * v2[2] * v3[0] * v4[4]) + (v0[3] * v1[1] * v2[2] * v3[4] * v4[0]) + (v0[3] * v1[1] * v2[4] * v3[0] * v4[2]) + (-1 * v0[3] * v1[1] * v2[4] * v3[2] * v4[0]) + (-1 * v0[3] * v1[2] * v2[0] * v3[1] * v4[4]) + (v0[3] * v1[2] * v2[0] * v3[4] * v4[1]) + (v0[3] * v1[2] * v2[1] * v3[0] * v4[4]) + (-1 * v0[3] * v1[2] * v2[1] * v3[4] * v4[0]) + (-1 * v0[3] * v1[2] * v2[4] * v3[0] * v4[1]) + (v0[3] * v1[2] * v2[4] * v3[1] * v4[0]) + (v0[3] * v1[4] * v2[0] * v3[1] * v4[2]) + (-1 * v0[3] * v1[4] * v2[0] * v3[2] * v4[1]) + (-1 * v0[3] * v1[4] * v2[1] * v3[0] * v4[2]) + (v0[3] * v1[4] * v2[1] * v3[2] * v4[0]) + (v0[3] * v1[4] * v2[2] * v3[0] * v4[1]) + (-1 * v0[3] * v1[4] * v2[2] * v3[1] * v4[0]) + (v0[4] * v1[0] * v2[1] * v3[2] * v4[3]) + (-1 * v0[4] * v1[0] * v2[1] * v3[3] * v4[2]) + (-1 * v0[4] * v1[0] * v2[2] * v3[1] * v4[3]) + (v0[4] * v1[0] * v2[2] * v3[3] * v4[1]) + (v0[4] * v1[0] * v2[3] * v3[1] * v4[2]) + (-1 * v0[4] * v1[0] * v2[3] * v3[2] * v4[1]) + (-1 * v0[4] * v1[1] * v2[0] * v3[2] * v4[3]) + (v0[4] * v1[1] * v2[0] * v3[3] * v4[2]) + (v0[4] * v1[1] * v2[2] * v3[0] * v4[3]) + (-1 * v0[4] * v1[1] * v2[2] * v3[3] * v4[0]) + (-1 * v0[4] * v1[1] * v2[3] * v3[0] * v4[2]) + (v0[4] * v1[1] * v2[3] * v3[2] * v4[0]) + (v0[4] * v1[2] * v2[0] * v3[1] * v4[3]) + (-1 * v0[4] * v1[2] * v2[0] * v3[3] * v4[1]) + (-1 * v0[4] * v1[2] * v2[1] * v3[0] * v4[3]) + (v0[4] * v1[2] * v2[1] * v3[3] * v4[0]) + (v0[4] * v1[2] * v2[3] * v3[0] * v4[1]) + (-1 * v0[4] * v1[2] * v2[3] * v3[1] * v4[0]) + (-1 * v0[4] * v1[3] * v2[0] * v3[1] * v4[2]) + (v0[4] * v1[3] * v2[0] * v3[2] * v4[1]) + (v0[4] * v1[3] * v2[1] * v3[0] * v4[2]) + (-1 * v0[4] * v1[3] * v2[1] * v3[2] * v4[0]) + (-1 * v0[4] * v1[3] * v2[2] * v3[0] * v4[1]) + (v0[4] * v1[3] * v2[2] * v3[1] * v4[0]);
}
void cross7(const float* v0, const float* v1, const float* v2, const float* v3, const float* v4, const float* v5, float *r0)
{
r0[0] = (v0[1] * v1[2] * v2[3] * v3[4] * v4[5] * v5[6]) + (-1 * v0[1] * v1[2] * v2[3] * v3[4] * v4[6] * v5[5]) + (-1 * v0[1] * v1[2] * v2[3] * v3[5] * v4[4] * v5[6]) + (v0[1] * v1[2] * v2[3] * v3[5] * v4[6] * v5[4]) + (v0[1] * v1[2] * v2[3] * v3[6] * v4[4] * v5[5]) + (-1 * v0[1] * v1[2] * v2[3] * v3[6] * v4[5] * v5[4]) + (-1 * v0[1] * v1[2] * v2[4] * v3[3] * v4[5] * v5[6]) + (v0[1] * v1[2] * v2[4] * v3[3] * v4[6] * v5[5]) + (v0[1] * v1[2] * v2[4] * v3[5] * v4[3] * v5[6]) + (-1 * v0[1] * v1[2] * v2[4] * v3[5] * v4[6] * v5[3]) + (-1 * v0[1] * v1[2] * v2[4] * v3[6] * v4[3] * v5[5]) + (v0[1] * v1[2] * v2[4] * v3[6] * v4[5] * v5[3]) + (v0[1] * v1[2] * v2[5] * v3[3] * v4[4] * v5[6]) + (-1 * v0[1] * v1[2] * v2[5] * v3[3] * v4[6] * v5[4]) + (-1 * v0[1] * v1[2] * v2[5] * v3[4] * v4[3] * v5[6]) + (v0[1] * v1[2] * v2[5] * v3[4] * v4[6] * v5[3]) + (v0[1] * v1[2] * v2[5] * v3[6] * v4[3] * v5[4]) + (-1 * v0[1] * v1[2] * v2[5] * v3[6] * v4[4] * v5[3]) + (-1 * v0[1] * v1[2] * v2[6] * v3[3] * v4[4] * v5[5]) + (v0[1] * v1[2] * v2[6] * v3[3] * v4[5] * v5[4]) + (v0[1] * v1[2] * v2[6] * v3[4] * v4[3] * v5[5]) + (-1 * v0[1] * v1[2] * v2[6] * v3[4] * v4[5] * v5[3]) + (-1 * v0[1] * v1[2] * v2[6] * v3[5] * v4[3] * v5[4]) + (v0[1] * v1[2] * v2[6] * v3[5] * v4[4] * v5[3]) + (-1 * v0[1] * v1[3] * v2[2] * v3[4] * v4[5] * v5[6]) + (v0[1] * v1[3] * v2[2] * v3[4] * v4[6] * v5[5]) + (v0[1] * v1[3] * v2[2] * v3[5] * v4[4] * v5[6]) + (-1 * v0[1] * v1[3] * v2[2] * v3[5] * v4[6] * v5[4]) + (-1 * v0[1] * v1[3] * v2[2] * v3[6] * v4[4] * v5[5]) + (v0[1] * v1[3] * v2[2] * v3[6] * v4[5] * v5[4]) + (v0[1] * v1[3] * v2[4] * v3[2] * v4[5] * v5[6]) + (-1 * v0[1] * v1[3] * v2[4] * v3[2] * v4[6] * v5[5]) + (-1 * v0[1] * v1[3] * v2[4] * v3[5] * v4[2] * v5[6]) + (v0[1] * v1[3] * v2[4] * v3[5] * v4[6] * v5[2]) + (v0[1] * v1[3] * v2[4] * v3[6] * v4[2] * v5[5]) + (-1 * v0[1] * v1[3] * v2[4] * v3[6] * v4[5] * v5[2]) + (-1 * v0[1] * v1[3] * v2[5] * v3[2] * v4[4] * v5[6]) + (v0[1] * v1[3] * v2[5] * v3[2] * v4[6] * v5[4]) + (v0[1] * v1[3] * v2[5] * v3[4] * v4[2] * v5[6]) + (-1 * v0[1] * v1[3] * v2[5] * v3[4] * v4[6] * v5[2]) + (-1 * v0[1] * v1[3] * v2[5] * v3[6] * v4[2] * v5[4]) + (v0[1] * v1[3] * v2[5] * v3[6] * v4[4] * v5[2]) + (v0[1] * v1[3] * v2[6] * v3[2] * v4[4] * v5[5]) + (-1 * v0[1] * v1[3] * v2[6] * v3[2] * v4[5] * v5[4]) + (-1 * v0[1] * v1[3] * v2[6] * v3[4] * v4[2] * v5[5]) + (v0[1] * v1[3] * v2[6] * v3[4] * v4[5] * v5[2]) + (v0[1] * v1[3] * v2[6] * v3[5] * v4[2] * v5[4]) + (-1 * v0[1] * v1[3] * v2[6] * v3[5] * v4[4] * v5[2]) + (v0[1] * v1[4] * v2[2] * v3[3] * v4[5] * v5[6]) + (-1 * v0[1] * v1[4] * v2[2] * v3[3] * v4[6] * v5[5]) + (-1 * v0[1] * v1[4] * v2[2] * v3[5] * v4[3] * v5[6]) + (v0[1] * v1[4] * v2[2] * v3[5] * v4[6] * v5[3]) + (v0[1] * v1[4] * v2[2] * v3[6] * v4[3] * v5[5]) + (-1 * v0[1] * v1[4] * v2[2] * v3[6] * v4[5] * v5[3]) + (-1 * v0[1] * v1[4] * v2[3] * v3[2] * v4[5] * v5[6]) + (v0[1] * v1[4] * v2[3] * v3[2] * v4[6] * v5[5]) + (v0[1] * v1[4] * v2[3] * v3[5] * v4[2] * v5[6]) + (-1 * v0[1] * v1[4] * v2[3] * v3[5] * v4[6] * v5[2]) + (-1 * v0[1] * v1[4] * v2[3] * v3[6] * v4[2] * v5[5]) + (v0[1] * v1[4] * v2[3] * v3[6] * v4[5] * v5[2]) + (v0[1] * v1[4] * v2[5] * v3[2] * v4[3] * v5[6]) + (-1 * v0[1] * v1[4] * v2[5] * v3[2] * v4[6] * v5[3]) + (-1 * v0[1] * v1[4] * v2[5] * v3[3] * v4[2] * v5[6]) + (v0[1] * v1[4] * v2[5] * v3[3] * v4[6] * v5[2]) + (v0[1] * v1[4] * v2[5] * v3[6] * v4[2] * v5[3]) + (-1 * v0[1] * v1[4] * v2[5] * v3[6] * v4[3] * v5[2]) + (-1 * v0[1] * v1[4] * v2[6] * v3[2] * v4[3] * v5[5]) + (v0[1] * v1[4] * v2[6] * v3[2] * v4[5] * v5[3]) + (v0[1] * v1[4] * v2[6] * v3[3] * v4[2] * v5[5]) + (-1 * v0[1] * v1[4] * v2[6] * v3[3] * v4[5] * v5[2]) + (-1 * v0[1] * v1[4] * v2[6] * v3[5] * v4[2] * v5[3]) + (v0[1] * v1[4] * v2[6] * v3[5] * v4[3] * v5[2]) + (-1 * v0[1] * v1[5] * v2[2] * v3[3] * v4[4] * v5[6]) + (v0[1] * v1[5] * v2[2] * v3[3] * v4[6] * v5[4]) + (v0[1] * v1[5] * v2[2] * v3[4] * v4[3] * v5[6]) + (-1 * v0[1] * v1[5] * v2[2] * v3[4] * v4[6] * v5[3]) + (-1 * v0[1] * v1[5] * v2[2] * v3[6] * v4[3] * v5[4]) + (v0[1] * v1[5] * v2[2] * v3[6] * v4[4] * v5[3]) + (v0[1] * v1[5] * v2[3] * v3[2] * v4[4] * v5[6]) + (-1 * v0[1] * v1[5] * v2[3] * v3[2] * v4[6] * v5[4]) + (-1 * v0[1] * v1[5] * v2[3] * v3[4] * v4[2] * v5[6]) + (v0[1] * v1[5] * v2[3] * v3[4] * v4[6] * v5[2]) + (v0[1] * v1[5] * v2[3] * v3[6] * v4[2] * v5[4]) + (-1 * v0[1] * v1[5] * v2[3] * v3[6] * v4[4] * v5[2]) + (-1 * v0[1] * v1[5] * v2[4] * v3[2] * v4[3] * v5[6]) + (v0[1] * v1[5] * v2[4] * v3[2] * v4[6] * v5[3]) + (v0[1] * v1[5] * v2[4] * v3[3] * v4[2] * v5[6]) + (-1 * v0[1] * v1[5] * v2[4] * v3[3] * v4[6] * v5[2]) + (-1 * v0[1] * v1[5] * v2[4] * v3[6] * v4[2] * v5[3]) + (v0[1] * v1[5] * v2[4] * v3[6] * v4[3] * v5[2]) + (v0[1] * v1[5] * v2[6] * v3[2] * v4[3] * v5[4]) + (-1 * v0[1] * v1[5] * v2[6] * v3[2] * v4[4] * v5[3]) + (-1 * v0[1] * v1[5] * v2[6] * v3[3] * v4[2] * v5[4]) + (v0[1] * v1[5] * v2[6] * v3[3] * v4[4] * v5[2]) + (v0[1] * v1[5] * v2[6] * v3[4] * v4[2] * v5[3]) + (-1 * v0[1] * v1[5] * v2[6] * v3[4] * v4[3] * v5[2]) + (v0[1] * v1[6] * v2[2] * v3[3] * v4[4] * v5[5]) + (-1 * v0[1] * v1[6] * v2[2] * v3[3] * v4[5] * v5[4]) + (-1 * v0[1] * v1[6] * v2[2] * v3[4] * v4[3] * v5[5]) + (v0[1] * v1[6] * v2[2] * v3[4] * v4[5] * v5[3]) + (v0[1] * v1[6] * v2[2] * v3[5] * v4[3] * v5[4]) + (-1 * v0[1] * v1[6] * v2[2] * v3[5] * v4[4] * v5[3]) + (-1 * v0[1] * v1[6] * v2[3] * v3[2] * v4[4] * v5[5]) + (v0[1] * v1[6] * v2[3] * v3[2] * v4[5] * v5[4]) + (v0[1] * v1[6] * v2[3] * v3[4] * v4[2] * v5[5]) + (-1 * v0[1] * v1[6] * v2[3] * v3[4] * v4[5] * v5[2]) + (-1 * v0[1] * v1[6] * v2[3] * v3[5] * v4[2] * v5[4]) + (v0[1] * v1[6] * v2[3] * v3[5] * v4[4] * v5[2]) + (v0[1] * v1[6] * v2[4] * v3[2] * v4[3] * v5[5]) + (-1 * v0[1] * v1[6] * v2[4] * v3[2] * v4[5] * v5[3]) + (-1 * v0[1] * v1[6] * v2[4] * v3[3] * v4[2] * v5[5]) + (v0[1] * v1[6] * v2[4] * v3[3] * v4[5] * v5[2]) + (v0[1] * v1[6] * v2[4] * v3[5] * v4[2] * v5[3]) + (-1 * v0[1] * v1[6] * v2[4] * v3[5] * v4[3] * v5[2]) + (-1 * v0[1] * v1[6] * v2[5] * v3[2] * v4[3] * v5[4]) + (v0[1] * v1[6] * v2[5] * v3[2] * v4[4] * v5[3]) + (v0[1] * v1[6] * v2[5] * v3[3] * v4[2] * v5[4]) + (-1 * v0[1] * v1[6] * v2[5] * v3[3] * v4[4] * v5[2]) + (-1 * v0[1] * v1[6] * v2[5] * v3[4] * v4[2] * v5[3]) + (v0[1] * v1[6] * v2[5] * v3[4] * v4[3] * v5[2]) + (-1 * v0[2] * v1[1] * v2[3] * v3[4] * v4[5] * v5[6]) + (v0[2] * v1[1] * v2[3] * v3[4] * v4[6] * v5[5]) + (v0[2] * v1[1] * v2[3] * v3[5] * v4[4] * v5[6]) + (-1 * v0[2] * v1[1] * v2[3] * v3[5] * v4[6] * v5[4]) + (-1 * v0[2] * v1[1] * v2[3] * v3[6] * v4[4] * v5[5]) + (v0[2] * v1[1] * v2[3] * v3[6] * v4[5] * v5[4]) + (v0[2] * v1[1] * v2[4] * v3[3] * v4[5] * v5[6]) + (-1 * v0[2] * v1[1] * v2[4] * v3[3] * v4[6] * v5[5]) + (-1 * v0[2] * v1[1] * v2[4] * v3[5] * v4[3] * v5[6]) + (v0[2] * v1[1] * v2[4] * v3[5] * v4[6] * v5[3]) + (v0[2] * v1[1] * v2[4] * v3[6] * v4[3] * v5[5]) + (-1 * v0[2] * v1[1] * v2[4] * v3[6] * v4[5] * v5[3]) + (-1 * v0[2] * v1[1] * v2[5] * v3[3] * v4[4] * v5[6]) + (v0[2] * v1[1] * v2[5] * v3[3] * v4[6] * v5[4]) + (v0[2] * v1[1] * v2[5] * v3[4] * v4[3] * v5[6]) + (-1 * v0[2] * v1[1] * v2[5] * v3[4] * v4[6] * v5[3]) + (-1 * v0[2] * v1[1] * v2[5] * v3[6] * v4[3] * v5[4]) + (v0[2] * v1[1] * v2[5] * v3[6] * v4[4] * v5[3]) + (v0[2] * v1[1] * v2[6] * v3[3] * v4[4] * v5[5]) + (-1 * v0[2] * v1[1] * v2[6] * v3[3] * v4[5] * v5[4]) + (-1 * v0[2] * v1[1] * v2[6] * v3[4] * v4[3] * v5[5]) + (v0[2] * v1[1] * v2[6] * v3[4] * v4[5] * v5[3]) + (v0[2] * v1[1] * v2[6] * v3[5] * v4[3] * v5[4]) + (-1 * v0[2] * v1[1] * v2[6] * v3[5] * v4[4] * v5[3]) + (v0[2] * v1[3] * v2[1] * v3[4] * v4[5] * v5[6]) + (-1 * v0[2] * v1[3] * v2[1] * v3[4] * v4[6] * v5[5]) + (-1 * v0[2] * v1[3] * v2[1] * v3[5] * v4[4] * v5[6]) + (v0[2] * v1[3] * v2[1] * v3[5] * v4[6] * v5[4]) + (v0[2] * v1[3] * v2[1] * v3[6] * v4[4] * v5[5]) + (-1 * v0[2] * v1[3] * v2[1] * v3[6] * v4[5] * v5[4]) + (-1 * v0[2] * v1[3] * v2[4] * v3[1] * v4[5] * v5[6]) + (v0[2] * v1[3] * v2[4] * v3[1] * v4[6] * v5[5]) + (v0[2] * v1[3] * v2[4] * v3[5] * v4[1] * v5[6]) + (-1 * v0[2] * v1[3] * v2[4] * v3[5] * v4[6] * v5[1]) + (-1 * v0[2] * v1[3] * v2[4] * v3[6] * v4[1] * v5[5]) + (v0[2] * v1[3] * v2[4] * v3[6] * v4[5] * v5[1]) + (v0[2] * v1[3] * v2[5] * v3[1] * v4[4] * v5[6]) + (-1 * v0[2] * v1[3] * v2[5] * v3[1] * v4[6] * v5[4]) + (-1 * v0[2] * v1[3] * v2[5] * v3[4] * v4[1] * v5[6]) + (v0[2] * v1[3] * v2[5] * v3[4] * v4[6] * v5[1]) + (v0[2] * v1[3] * v2[5] * v3[6] * v4[1] * v5[4]) + (-1 * v0[2] * v1[3] * v2[5] * v3[6] * v4[4] * v5[1]) + (-1 * v0[2] * v1[3] * v2[6] * v3[1] * v4[4] * v5[5]) + (v0[2] * v1[3] * v2[6] * v3[1] * v4[5] * v5[4]) + (v0[2] * v1[3] * v2[6] * v3[4] * v4[1] * v5[5]) + (-1 * v0[2] * v1[3] * v2[6] * v3[4] * v4[5] * v5[1]) + (-1 * v0[2] * v1[3] * v2[6] * v3[5] * v4[1] * v5[4]) + (v0[2] * v1[3] * v2[6] * v3[5] * v4[4] * v5[1]) + (-1 * v0[2] * v1[4] * v2[1] * v3[3] * v4[5] * v5[6]) + (v0[2] * v1[4] * v2[1] * v3[3] * v4[6] * v5[5]) + (v0[2] * v1[4] * v2[1] * v3[5] * v4[3] * v5[6]) + (-1 * v0[2] * v1[4] * v2[1] * v3[5] * v4[6] * v5[3]) + (-1 * v0[2] * v1[4] * v2[1] * v3[6] * v4[3] * v5[5]) + (v0[2] * v1[4] * v2[1] * v3[6] * v4[5] * v5[3]) + (v0[2] * v1[4] * v2[3] * v3[1] * v4[5] * v5[6]) + (-1 * v0[2] * v1[4] * v2[3] * v3[1] * v4[6] * v5[5]) + (-1 * v0[2] * v1[4] * v2[3] * v3[5] * v4[1] * v5[6]) + (v0[2] * v1[4] * v2[3] * v3[5] * v4[6] * v5[1]) + (v0[2] * v1[4] * v2[3] * v3[6] * v4[1] * v5[5]) + (-1 * v0[2] * v1[4] * v2[3] * v3[6] * v4[5] * v5[1]) + (-1 * v0[2] * v1[4] * v2[5] * v3[1] * v4[3] * v5[6]) + (v0[2] * v1[4] * v2[5] * v3[1] * v4[6] * v5[3]) + (v0[2] * v1[4] * v2[5] * v3[3] * v4[1] * v5[6]) + (-1 * v0[2] * v1[4] * v2[5] * v3[3] * v4[6] * v5[1]) + (-1 * v0[2] * v1[4] * v2[5] * v3[6] * v4[1] * v5[3]) + (v0[2] * v1[4] * v2[5] * v3[6] * v4[3] * v5[1]) + (v0[2] * v1[4] * v2[6] * v3[1] * v4[3] * v5[5]) + (-1 * v0[2] * v1[4] * v2[6] * v3[1] * v4[5] * v5[3]) + (-1 * v0[2] * v1[4] * v2[6] * v3[3] * v4[1] * v5[5]) + (v0[2] * v1[4] * v2[6] * v3[3] * v4[5] * v5[1]) + (v0[2] * v1[4] * v2[6] * v3[5] * v4[1] * v5[3]) + (-1 * v0[2] * v1[4] * v2[6] * v3[5] * v4[3] * v5[1]) + (v0[2] * v1[5] * v2[1] * v3[3] * v4[4] * v5[6]) + (-1 * v0[2] * v1[5] * v2[1] * v3[3] * v4[6] * v5[4]) + (-1 * v0[2] * v1[5] * v2[1] * v3[4] * v4[3] * v5[6]) + (v0[2] * v1[5] * v2[1] * v3[4] * v4[6] * v5[3]) + (v0[2] * v1[5] * v2[1] * v3[6] * v4[3] * v5[4]) + (-1 * v0[2] * v1[5] * v2[1] * v3[6] * v4[4] * v5[3]) + (-1 * v0[2] * v1[5] * v2[3] * v3[1] * v4[4] * v5[6]) + (v0[2] * v1[5] * v2[3] * v3[1] * v4[6] * v5[4]) + (v0[2] * v1[5] * v2[3] * v3[4] * v4[1] * v5[6]) + (-1 * v0[2] * v1[5] * v2[3] * v3[4] * v4[6] * v5[1]) + (-1 * v0[2] * v1[5] * v2[3] * v3[6] * v4[1] * v5[4]) + (v0[2] * v1[5] * v2[3] * v3[6] * v4[4] * v5[1]) + (v0[2] * v1[5] * v2[4] * v3[1] * v4[3] * v5[6]) + (-1 * v0[2] * v1[5] * v2[4] * v3[1] * v4[6] * v5[3]) + (-1 * v0[2] * v1[5] * v2[4] * v3[3] * v4[1] * v5[6]) + (v0[2] * v1[5] * v2[4] * v3[3] * v4[6] * v5[1]) + (v0[2] * v1[5] * v2[4] * v3[6] * v4[1] * v5[3]) + (-1 * v0[2] * v1[5] * v2[4] * v3[6] * v4[3] * v5[1]) + (-1 * v0[2] * v1[5] * v2[6] * v3[1] * v4[3] * v5[4]) + (v0[2] * v1[5] * v2[6] * v3[1] * v4[4] * v5[3]) + (v0[2] * v1[5] * v2[6] * v3[3] * v4[1] * v5[4]) + (-1 * v0[2] * v1[5] * v2[6] * v3[3] * v4[4] * v5[1]) + (-1 * v0[2] * v1[5] * v2[6] * v3[4] * v4[1] * v5[3]) + (v0[2] * v1[5] * v2[6] * v3[4] * v4[3] * v5[1]) + (-1 * v0[2] * v1[6] * v2[1] * v3[3] * v4[4] * v5[5]) + (v0[2] * v1[6] * v2[1] * v3[3] * v4[5] * v5[4]) + (v0[2] * v1[6] * v2[1] * v3[4] * v4[3] * v5[5]) + (-1 * v0[2] * v1[6] * v2[1] * v3[4] * v4[5] * v5[3]) + (-1 * v0[2] * v1[6] * v2[1] * v3[5] * v4[3] * v5[4]) + (v0[2] * v1[6] * v2[1] * v3[5] * v4[4] * v5[3]) + (v0[2] * v1[6] * v2[3] * v3[1] * v4[4] * v5[5]) + (-1 * v0[2] * v1[6] * v2[3] * v3[1] * v4[5] * v5[4]) + (-1 * v0[2] * v1[6] * v2[3] * v3[4] * v4[1] * v5[5]) + (v0[2] * v1[6] * v2[3] * v3[4] * v4[5] * v5[1]) + (v0[2] * v1[6] * v2[3] * v3[5] * v4[1] * v5[4]) + (-1 * v0[2] * v1[6] * v2[3] * v3[5] * v4[4] * v5[1]) + (-1 * v0[2] * v1[6] * v2[4] * v3[1] * v4[3] * v5[5]) + (v0[2] * v1[6] * v2[4] * v3[1] * v4[5] * v5[3]) + (v0[2] * v1[6] * v2[4] * v3[3] * v4[1] * v5[5]) + (-1 * v0[2] * v1[6] * v2[4] * v3[3] * v4[5] * v5[1]) + (-1 * v0[2] * v1[6] * v2[4] * v3[5] * v4[1] * v5[3]) + (v0[2] * v1[6] * v2[4] * v3[5] * v4[3] * v5[1]) + (v0[2] * v1[6] * v2[5] * v3[1] * v4[3] * v5[4]) + (-1 * v0[2] * v1[6] * v2[5] * v3[1] * v4[4] * v5[3]) + (-1 * v0[2] * v1[6] * v2[5] * v3[3] * v4[1] * v5[4]) + (v0[2] * v1[6] * v2[5] * v3[3] * v4[4] * v5[1]) + (v0[2] * v1[6] * v2[5] * v3[4] * v4[1] * v5[3]) + (-1 * v0[2] * v1[6] * v2[5] * v3[4] * v4[3] * v5[1]) + (v0[3] * v1[1] * v2[2] * v3[4] * v4[5] * v5[6]) + (-1 * v0[3] * v1[1] * v2[2] * v3[4] * v4[6] * v5[5]) + (-1 * v0[3] * v1[1] * v2[2] * v3[5] * v4[4] * v5[6]) + (v0[3] * v1[1] * v2[2] * v3[5] * v4[6] * v5[4]) + (v0[3] * v1[1] * v2[2] * v3[6] * v4[4] * v5[5]) + (-1 * v0[3] * v1[1] * v2[2] * v3[6] * v4[5] * v5[4]) + (-1 * v0[3] * v1[1] * v2[4] * v3[2] * v4[5] * v5[6]) + (v0[3] * v1[1] * v2[4] * v3[2] * v4[6] * v5[5]) + (v0[3] * v1[1] * v2[4] * v3[5] * v4[2] * v5[6]) + (-1 * v0[3] * v1[1] * v2[4] * v3[5] * v4[6] * v5[2]) + (-1 * v0[3] * v1[1] * v2[4] * v3[6] * v4[2] * v5[5]) + (v0[3] * v1[1] * v2[4] * v3[6] * v4[5] * v5[2]) + (v0[3] * v1[1] * v2[5] * v3[2] * v4[4] * v5[6]) + (-1 * v0[3] * v1[1] * v2[5] * v3[2] * v4[6] * v5[4]) + (-1 * v0[3] * v1[1] * v2[5] * v3[4] * v4[2] * v5[6]) + (v0[3] * v1[1] * v2[5] * v3[4] * v4[6] * v5[2]) + (v0[3] * v1[1] * v2[5] * v3[6] * v4[2] * v5[4]) + (-1 * v0[3] * v1[1] * v2[5] * v3[6] * v4[4] * v5[2]) + (-1 * v0[3] * v1[1] * v2[6] * v3[2] * v4[4] * v5[5]) + (v0[3] * v1[1] * v2[6] * v3[2] * v4[5] * v5[4]) + (v0[3] * v1[1] * v2[6] * v3[4] * v4[2] * v5[5]) + (-1 * v0[3] * v1[1] * v2[6] * v3[4] * v4[5] * v5[2]) + (-1 * v0[3] * v1[1] * v2[6] * v3[5] * v4[2] * v5[4]) + (v0[3] * v1[1] * v2[6] * v3[5] * v4[4] * v5[2]) + (-1 * v0[3] * v1[2] * v2[1] * v3[4] * v4[5] * v5[6]) + (v0[3] * v1[2] * v2[1] * v3[4] * v4[6] * v5[5]) + (v0[3] * v1[2] * v2[1] * v3[5] * v4[4] * v5[6]) + (-1 * v0[3] * v1[2] * v2[1] * v3[5] * v4[6] * v5[4]) + (-1 * v0[3] * v1[2] * v2[1] * v3[6] * v4[4] * v5[5]) + (v0[3] * v1[2] * v2[1] * v3[6] * v4[5] * v5[4]) + (v0[3] * v1[2] * v2[4] * v3[1] * v4[5] * v5[6]) + (-1 * v0[3] * v1[2] * v2[4] * v3[1] * v4[6] * v5[5]) + (-1 * v0[3] * v1[2] * v2[4] * v3[5] * v4[1] * v5[6]) + (v0[3] * v1[2] * v2[4] * v3[5] * v4[6] * v5[1]) + (v0[3] * v1[2] * v2[4] * v3[6] * v4[1] * v5[5]) + (-1 * v0[3] * v1[2] * v2[4] * v3[6] * v4[5] * v5[1]) + (-1 * v0[3] * v1[2] * v2[5] * v3[1] * v4[4] * v5[6]) + (v0[3] * v1[2] * v2[5] * v3[1] * v4[6] * v5[4]) + (v0[3] * v1[2] * v2[5] * v3[4] * v4[1] * v5[6]) + (-1 * v0[3] * v1[2] * v2[5] * v3[4] * v4[6] * v5[1]) + (-1 * v0[3] * v1[2] * v2[5] * v3[6] * v4[1] * v5[4]) + (v0[3] * v1[2] * v2[5] * v3[6] * v4[4] * v5[1]) + (v0[3] * v1[2] * v2[6] * v3[1] * v4[4] * v5[5]) + (-1 * v0[3] * v1[2] * v2[6] * v3[1] * v4[5] * v5[4]) + (-1 * v0[3] * v1[2] * v2[6] * v3[4] * v4[1] * v5[5]) + (v0[3] * v1[2] * v2[6] * v3[4] * v4[5] * v5[1]) + (v0[3] * v1[2] * v2[6] * v3[5] * v4[1] * v5[4]) + (-1 * v0[3] * v1[2] * v2[6] * v3[5] * v4[4] * v5[1]) + (v0[3] * v1[4] * v2[1] * v3[2] * v4[5] * v5[6]) + (-1 * v0[3] * v1[4] * v2[1] * v3[2] * v4[6] * v5[5]) + (-1 * v0[3] * v1[4] * v2[1] * v3[5] * v4[2] * v5[6]) + (v0[3] * v1[4] * v2[1] * v3[5] * v4[6] * v5[2]) + (v0[3] * v1[4] * v2[1] * v3[6] * v4[2] * v5[5]) + (-1 * v0[3] * v1[4] * v2[1] * v3[6] * v4[5] * v5[2]) + (-1 * v0[3] * v1[4] * v2[2] * v3[1] * v4[5] * v5[6]) + (v0[3] * v1[4] * v2[2] * v3[1] * v4[6] * v5[5]) + (v0[3] * v1[4] * v2[2] * v3[5] * v4[1] * v5[6]) + (-1 * v0[3] * v1[4] * v2[2] * v3[5] * v4[6] * v5[1]) + (-1 * v0[3] * v1[4] * v2[2] * v3[6] * v4[1] * v5[5]) + (v0[3] * v1[4] * v2[2] * v3[6] * v4[5] * v5[1]) + (v0[3] * v1[4] * v2[5] * v3[1] * v4[2] * v5[6]) + (-1 * v0[3] * v1[4] * v2[5] * v3[1] * v4[6] * v5[2]) + (-1 * v0[3] * v1[4] * v2[5] * v3[2] * v4[1] * v5[6]) + (v0[3] * v1[4] * v2[5] * v3[2] * v4[6] * v5[1]) + (v0[3] * v1[4] * v2[5] * v3[6] * v4[1] * v5[2]) + (-1 * v0[3] * v1[4] * v2[5] * v3[6] * v4[2] * v5[1]) + (-1 * v0[3] * v1[4] * v2[6] * v3[1] * v4[2] * v5[5]) + (v0[3] * v1[4] * v2[6] * v3[1] * v4[5] * v5[2]) + (v0[3] * v1[4] * v2[6] * v3[2] * v4[1] * v5[5]) + (-1 * v0[3] * v1[4] * v2[6] * v3[2] * v4[5] * v5[1]) + (-1 * v0[3] * v1[4] * v2[6] * v3[5] * v4[1] * v5[2]) + (v0[3] * v1[4] * v2[6] * v3[5] * v4[2] * v5[1]) + (-1 * v0[3] * v1[5] * v2[1] * v3[2] * v4[4] * v5[6]) + (v0[3] * v1[5] * v2[1] * v3[2] * v4[6] * v5[4]) + (v0[3] * v1[5] * v2[1] * v3[4] * v4[2] * v5[6]) + (-1 * v0[3] * v1[5] * v2[1] * v3[4] * v4[6] * v5[2]) + (-1 * v0[3] * v1[5] * v2[1] * v3[6] * v4[2] * v5[4]) + (v0[3] * v1[5] * v2[1] * v3[6] * v4[4] * v5[2]) + (v0[3] * v1[5] * v2[2] * v3[1] * v4[4] * v5[6]) + (-1 * v0[3] * v1[5] * v2[2] * v3[1] * v4[6] * v5[4]) + (-1 * v0[3] * v1[5] * v2[2] * v3[4] * v4[1] * v5[6]) + (v0[3] * v1[5] * v2[2] * v3[4] * v4[6] * v5[1]) + (v0[3] * v1[5] * v2[2] * v3[6] * v4[1] * v5[4]) + (-1 * v0[3] * v1[5] * v2[2] * v3[6] * v4[4] * v5[1]) + (-1 * v0[3] * v1[5] * v2[4] * v3[1] * v4[2] * v5[6]) + (v0[3] * v1[5] * v2[4] * v3[1] * v4[6] * v5[2]) + (v0[3] * v1[5] * v2[4] * v3[2] * v4[1] * v5[6]) + (-1 * v0[3] * v1[5] * v2[4] * v3[2] * v4[6] * v5[1]) + (-1 * v0[3] * v1[5] * v2[4] * v3[6] * v4[1] * v5[2]) + (v0[3] * v1[5] * v2[4] * v3[6] * v4[2] * v5[1]) + (v0[3] * v1[5] * v2[6] * v3[1] * v4[2] * v5[4]) + (-1 * v0[3] * v1[5] * v2[6] * v3[1] * v4[4] * v5[2]) + (-1 * v0[3] * v1[5] * v2[6] * v3[2] * v4[1] * v5[4]) + (v0[3] * v1[5] * v2[6] * v3[2] * v4[4] * v5[1]) + (v0[3] * v1[5] * v2[6] * v3[4] * v4[1] * v5[2]) + (-1 * v0[3] * v1[5] * v2[6] * v3[4] * v4[2] * v5[1]) + (v0[3] * v1[6] * v2[1] * v3[2] * v4[4] * v5[5]) + (-1 * v0[3] * v1[6] * v2[1] * v3[2] * v4[5] * v5[4]) + (-1 * v0[3] * v1[6] * v2[1] * v3[4] * v4[2] * v5[5]) + (v0[3] * v1[6] * v2[1] * v3[4] * v4[5] * v5[2]) + (v0[3] * v1[6] * v2[1] * v3[5] * v4[2] * v5[4]) + (-1 * v0[3] * v1[6] * v2[1] * v3[5] * v4[4] * v5[2]) + (-1 * v0[3] * v1[6] * v2[2] * v3[1] * v4[4] * v5[5]) + (v0[3] * v1[6] * v2[2] * v3[1] * v4[5] * v5[4]) + (v0[3] * v1[6] * v2[2] * v3[4] * v4[1] * v5[5]) + (-1 * v0[3] * v1[6] * v2[2] * v3[4] * v4[5] * v5[1]) + (-1 * v0[3] * v1[6] * v2[2] * v3[5] * v4[1] * v5[4]) + (v0[3] * v1[6] * v2[2] * v3[5] * v4[4] * v5[1]) + (v0[3] * v1[6] * v2[4] * v3[1] * v4[2] * v5[5]) + (-1 * v0[3] * v1[6] * v2[4] * v3[1] * v4[5] * v5[2]) + (-1 * v0[3] * v1[6] * v2[4] * v3[2] * v4[1] * v5[5]) + (v0[3] * v1[6] * v2[4] * v3[2] * v4[5] * v5[1]) + (v0[3] * v1[6] * v2[4] * v3[5] * v4[1] * v5[2]) + (-1 * v0[3] * v1[6] * v2[4] * v3[5] * v4[2] * v5[1]) + (-1 * v0[3] * v1[6] * v2[5] * v3[1] * v4[2] * v5[4]) + (v0[3] * v1[6] * v2[5] * v3[1] * v4[4] * v5[2]) + (v0[3] * v1[6] * v2[5] * v3[2] * v4[1] * v5[4]) + (-1 * v0[3] * v1[6] * v2[5] * v3[2] * v4[4] * v5[1]) + (-1 * v0[3] * v1[6] * v2[5] * v3[4] * v4[1] * v5[2]) + (v0[3] * v1[6] * v2[5] * v3[4] * v4[2] * v5[1]) + (-1 * v0[4] * v1[1] * v2[2] * v3[3] * v4[5] * v5[6]) + (v0[4] * v1[1] * v2[2] * v3[3] * v4[6] * v5[5]) + (v0[4] * v1[1] * v2[2] * v3[5] * v4[3] * v5[6]) + (-1 * v0[4] * v1[1] * v2[2] * v3[5] * v4[6] * v5[3]) + (-1 * v0[4] * v1[1] * v2[2] * v3[6] * v4[3] * v5[5]) + (v0[4] * v1[1] * v2[2] * v3[6] * v4[5] * v5[3]) + (v0[4] * v1[1] * v2[3] * v3[2] * v4[5] * v5[6]) + (-1 * v0[4] * v1[1] * v2[3] * v3[2] * v4[6] * v5[5]) + (-1 * v0[4] * v1[1] * v2[3] * v3[5] * v4[2] * v5[6]) + (v0[4] * v1[1] * v2[3] * v3[5] * v4[6] * v5[2]) + (v0[4] * v1[1] * v2[3] * v3[6] * v4[2] * v5[5]) + (-1 * v0[4] * v1[1] * v2[3] * v3[6] * v4[5] * v5[2]) + (-1 * v0[4] * v1[1] * v2[5] * v3[2] * v4[3] * v5[6]) + (v0[4] * v1[1] * v2[5] * v3[2] * v4[6] * v5[3]) + (v0[4] * v1[1] * v2[5] * v3[3] * v4[2] * v5[6]) + (-1 * v0[4] * v1[1] * v2[5] * v3[3] * v4[6] * v5[2]) + (-1 * v0[4] * v1[1] * v2[5] * v3[6] * v4[2] * v5[3]) + (v0[4] * v1[1] * v2[5] * v3[6] * v4[3] * v5[2]) + (v0[4] * v1[1] * v2[6] * v3[2] * v4[3] * v5[5]) + (-1 * v0[4] * v1[1] * v2[6] * v3[2] * v4[5] * v5[3]) + (-1 * v0[4] * v1[1] * v2[6] * v3[3] * v4[2] * v5[5]) + (v0[4] * v1[1] * v2[6] * v3[3] * v4[5] * v5[2]) + (v0[4] * v1[1] * v2[6] * v3[5] * v4[2] * v5[3]) + (-1 * v0[4] * v1[1] * v2[6] * v3[5] * v4[3] * v5[2]) + (v0[4] * v1[2] * v2[1] * v3[3] * v4[5] * v5[6]) + (-1 * v0[4] * v1[2] * v2[1] * v3[3] * v4[6] * v5[5]) + (-1 * v0[4] * v1[2] * v2[1] * v3[5] * v4[3] * v5[6]) + (v0[4] * v1[2] * v2[1] * v3[5] * v4[6] * v5[3]) + (v0[4] * v1[2] * v2[1] * v3[6] * v4[3] * v5[5]) + (-1 * v0[4] * v1[2] * v2[1] * v3[6] * v4[5] * v5[3]) + (-1 * v0[4] * v1[2] * v2[3] * v3[1] * v4[5] * v5[6]) + (v0[4] * v1[2] * v2[3] * v3[1] * v4[6] * v5[5]) + (v0[4] * v1[2] * v2[3] * v3[5] * v4[1] * v5[6]) + (-1 * v0[4] * v1[2] * v2[3] * v3[5] * v4[6] * v5[1]) + (-1 * v0[4] * v1[2] * v2[3] * v3[6] * v4[1] * v5[5]) + (v0[4] * v1[2] * v2[3] * v3[6] * v4[5] * v5[1]) + (v0[4] * v1[2] * v2[5] * v3[1] * v4[3] * v5[6]) + (-1 * v0[4] * v1[2] * v2[5] * v3[1] * v4[6] * v5[3]) + (-1 * v0[4] * v1[2] * v2[5] * v3[3] * v4[1] * v5[6]) + (v0[4] * v1[2] * v2[5] * v3[3] * v4[6] * v5[1]) + (v0[4] * v1[2] * v2[5] * v3[6] * v4[1] * v5[3]) + (-1 * v0[4] * v1[2] * v2[5] * v3[6] * v4[3] * v5[1]) + (-1 * v0[4] * v1[2] * v2[6] * v3[1] * v4[3] * v5[5]) + (v0[4] * v1[2] * v2[6] * v3[1] * v4[5] * v5[3]) + (v0[4] * v1[2] * v2[6] * v3[3] * v4[1] * v5[5]) + (-1 * v0[4] * v1[2] * v2[6] * v3[3] * v4[5] * v5[1]) + (-1 * v0[4] * v1[2] * v2[6] * v3[5] * v4[1] * v5[3]) + (v0[4] * v1[2] * v2[6] * v3[5] * v4[3] * v5[1]) + (-1 * v0[4] * v1[3] * v2[1] * v3[2] * v4[5] * v5[6]) + (v0[4] * v1[3] * v2[1] * v3[2] * v4[6] * v5[5]) + (v0[4] * v1[3] * v2[1] * v3[5] * v4[2] * v5[6]) + (-1 * v0[4] * v1[3] * v2[1] * v3[5] * v4[6] * v5[2]) + (-1 * v0[4] * v1[3] * v2[1] * v3[6] * v4[2] * v5[5]) + (v0[4] * v1[3] * v2[1] * v3[6] * v4[5] * v5[2]) + (v0[4] * v1[3] * v2[2] * v3[1] * v4[5] * v5[6]) + (-1 * v0[4] * v1[3] * v2[2] * v3[1] * v4[6] * v5[5]) + (-1 * v0[4] * v1[3] * v2[2] * v3[5] * v4[1] * v5[6]) + (v0[4] * v1[3] * v2[2] * v3[5] * v4[6] * v5[1]) + (v0[4] * v1[3] * v2[2] * v3[6] * v4[1] * v5[5]) + (-1 * v0[4] * v1[3] * v2[2] * v3[6] * v4[5] * v5[1]) + (-1 * v0[4] * v1[3] * v2[5] * v3[1] * v4[2] * v5[6]) + (v0[4] * v1[3] * v2[5] * v3[1] * v4[6] * v5[2]) + (v0[4] * v1[3] * v2[5] * v3[2] * v4[1] * v5[6]) + (-1 * v0[4] * v1[3] * v2[5] * v3[2] * v4[6] * v5[1]) + (-1 * v0[4] * v1[3] * v2[5] * v3[6] * v4[1] * v5[2]) + (v0[4] * v1[3] * v2[5] * v3[6] * v4[2] * v5[1]) + (v0[4] * v1[3] * v2[6] * v3[1] * v4[2] * v5[5]) + (-1 * v0[4] * v1[3] * v2[6] * v3[1] * v4[5] * v5[2]) + (-1 * v0[4] * v1[3] * v2[6] * v3[2] * v4[1] * v5[5]) + (v0[4] * v1[3] * v2[6] * v3[2] * v4[5] * v5[1]) + (v0[4] * v1[3] * v2[6] * v3[5] * v4[1] * v5[2]) + (-1 * v0[4] * v1[3] * v2[6] * v3[5] * v4[2] * v5[1]) + (v0[4] * v1[5] * v2[1] * v3[2] * v4[3] * v5[6]) + (-1 * v0[4] * v1[5] * v2[1] * v3[2] * v4[6] * v5[3]) + (-1 * v0[4] * v1[5] * v2[1] * v3[3] * v4[2] * v5[6]) + (v0[4] * v1[5] * v2[1] * v3[3] * v4[6] * v5[2]) + (v0[4] * v1[5] * v2[1] * v3[6] * v4[2] * v5[3]) + (-1 * v0[4] * v1[5] * v2[1] * v3[6] * v4[3] * v5[2]) + (-1 * v0[4] * v1[5] * v2[2] * v3[1] * v4[3] * v5[6]) + (v0[4] * v1[5] * v2[2] * v3[1] * v4[6] * v5[3]) + (v0[4] * v1[5] * v2[2] * v3[3] * v4[1] * v5[6]) + (-1 * v0[4] * v1[5] * v2[2] * v3[3] * v4[6] * v5[1]) + (-1 * v0[4] * v1[5] * v2[2] * v3[6] * v4[1] * v5[3]) + (v0[4] * v1[5] * v2[2] * v3[6] * v4[3] * v5[1]) + (v0[4] * v1[5] * v2[3] * v3[1] * v4[2] * v5[6]) + (-1 * v0[4] * v1[5] * v2[3] * v3[1] * v4[6] * v5[2]) + (-1 * v0[4] * v1[5] * v2[3] * v3[2] * v4[1] * v5[6]) + (v0[4] * v1[5] * v2[3] * v3[2] * v4[6] * v5[1]) + (v0[4] * v1[5] * v2[3] * v3[6] * v4[1] * v5[2]) + (-1 * v0[4] * v1[5] * v2[3] * v3[6] * v4[2] * v5[1]) + (-1 * v0[4] * v1[5] * v2[6] * v3[1] * v4[2] * v5[3]) + (v0[4] * v1[5] * v2[6] * v3[1] * v4[3] * v5[2]) + (v0[4] * v1[5] * v2[6] * v3[2] * v4[1] * v5[3]) + (-1 * v0[4] * v1[5] * v2[6] * v3[2] * v4[3] * v5[1]) + (-1 * v0[4] * v1[5] * v2[6] * v3[3] * v4[1] * v5[2]) + (v0[4] * v1[5] * v2[6] * v3[3] * v4[2] * v5[1]) + (-1 * v0[4] * v1[6] * v2[1] * v3[2] * v4[3] * v5[5]) + (v0[4] * v1[6] * v2[1] * v3[2] * v4[5] * v5[3]) + (v0[4] * v1[6] * v2[1] * v3[3] * v4[2] * v5[5]) + (-1 * v0[4] * v1[6] * v2[1] * v3[3] * v4[5] * v5[2]) + (-1 * v0[4] * v1[6] * v2[1] * v3[5] * v4[2] * v5[3]) + (v0[4] * v1[6] * v2[1] * v3[5] * v4[3] * v5[2]) + (v0[4] * v1[6] * v2[2] * v3[1] * v4[3] * v5[5]) + (-1 * v0[4] * v1[6] * v2[2] * v3[1] * v4[5] * v5[3]) + (-1 * v0[4] * v1[6] * v2[2] * v3[3] * v4[1] * v5[5]) + (v0[4] * v1[6] * v2[2] * v3[3] * v4[5] * v5[1]) + (v0[4] * v1[6] * v2[2] * v3[5] * v4[1] * v5[3]) + (-1 * v0[4] * v1[6] * v2[2] * v3[5] * v4[3] * v5[1]) + (-1 * v0[4] * v1[6] * v2[3] * v3[1] * v4[2] * v5[5]) + (v0[4] * v1[6] * v2[3] * v3[1] * v4[5] * v5[2]) + (v0[4] * v1[6] * v2[3] * v3[2] * v4[1] * v5[5]) + (-1 * v0[4] * v1[6] * v2[3] * v3[2] * v4[5] * v5[1]) + (-1 * v0[4] * v1[6] * v2[3] * v3[5] * v4[1] * v5[2]) + (v0[4] * v1[6] * v2[3] * v3[5] * v4[2] * v5[1]) + (v0[4] * v1[6] * v2[5] * v3[1] * v4[2] * v5[3]) + (-1 * v0[4] * v1[6] * v2[5] * v3[1] * v4[3] * v5[2]) + (-1 * v0[4] * v1[6] * v2[5] * v3[2] * v4[1] * v5[3]) + (v0[4] * v1[6] * v2[5] * v3[2] * v4[3] * v5[1]) + (v0[4] * v1[6] * v2[5] * v3[3] * v4[1] * v5[2]) + (-1 * v0[4] * v1[6] * v2[5] * v3[3] * v4[2] * v5[1]) + (v0[5] * v1[1] * v2[2] * v3[3] * v4[4] * v5[6]) + (-1 * v0[5] * v1[1] * v2[2] * v3[3] * v4[6] * v5[4]) + (-1 * v0[5] * v1[1] * v2[2] * v3[4] * v4[3] * v5[6]) + (v0[5] * v1[1] * v2[2] * v3[4] * v4[6] * v5[3]) + (v0[5] * v1[1] * v2[2] * v3[6] * v4[3] * v5[4]) + (-1 * v0[5] * v1[1] * v2[2] * v3[6] * v4[4] * v5[3]) + (-1 * v0[5] * v1[1] * v2[3] * v3[2] * v4[4] * v5[6]) + (v0[5] * v1[1] * v2[3] * v3[2] * v4[6] * v5[4]) + (v0[5] * v1[1] * v2[3] * v3[4] * v4[2] * v5[6]) + (-1 * v0[5] * v1[1] * v2[3] * v3[4] * v4[6] * v5[2]) + (-1 * v0[5] * v1[1] * v2[3] * v3[6] * v4[2] * v5[4]) + (v0[5] * v1[1] * v2[3] * v3[6] * v4[4] * v5[2]) + (v0[5] * v1[1] * v2[4] * v3[2] * v4[3] * v5[6]) + (-1 * v0[5] * v1[1] * v2[4] * v3[2] * v4[6] * v5[3]) + (-1 * v0[5] * v1[1] * v2[4] * v3[3] * v4[2] * v5[6]) + (v0[5] * v1[1] * v2[4] * v3[3] * v4[6] * v5[2]) + (v0[5] * v1[1] * v2[4] * v3[6] * v4[2] * v5[3]) + (-1 * v0[5] * v1[1] * v2[4] * v3[6] * v4[3] * v5[2]) + (-1 * v0[5] * v1[1] * v2[6] * v3[2] * v4[3] * v5[4]) + (v0[5] * v1[1] * v2[6] * v3[2] * v4[4] * v5[3]) + (v0[5] * v1[1] * v2[6] * v3[3] * v4[2] * v5[4]) + (-1 * v0[5] * v1[1] * v2[6] * v3[3] * v4[4] * v5[2]) + (-1 * v0[5] * v1[1] * v2[6] * v3[4] * v4[2] * v5[3]) + (v0[5] * v1[1] * v2[6] * v3[4] * v4[3] * v5[2]) + (-1 * v0[5] * v1[2] * v2[1] * v3[3] * v4[4] * v5[6]) + (v0[5] * v1[2] * v2[1] * v3[3] * v4[6] * v5[4]) + (v0[5] * v1[2] * v2[1] * v3[4] * v4[3] * v5[6]) + (-1 * v0[5] * v1[2] * v2[1] * v3[4] * v4[6] * v5[3]) + (-1 * v0[5] * v1[2] * v2[1] * v3[6] * v4[3] * v5[4]) + (v0[5] * v1[2] * v2[1] * v3[6] * v4[4] * v5[3]) + (v0[5] * v1[2] * v2[3] * v3[1] * v4[4] * v5[6]) + (-1 * v0[5] * v1[2] * v2[3] * v3[1] * v4[6] * v5[4]) + (-1 * v0[5] * v1[2] * v2[3] * v3[4] * v4[1] * v5[6]) + (v0[5] * v1[2] * v2[3] * v3[4] * v4[6] * v5[1]) + (v0[5] * v1[2] * v2[3] * v3[6] * v4[1] * v5[4]) + (-1 * v0[5] * v1[2] * v2[3] * v3[6] * v4[4] * v5[1]) + (-1 * v0[5] * v1[2] * v2[4] * v3[1] * v4[3] * v5[6]) + (v0[5] * v1[2] * v2[4] * v3[1] * v4[6] * v5[3]) + (v0[5] * v1[2] * v2[4] * v3[3] * v4[1] * v5[6]) + (-1 * v0[5] * v1[2] * v2[4] * v3[3] * v4[6] * v5[1]) + (-1 * v0[5] * v1[2] * v2[4] * v3[6] * v4[1] * v5[3]) + (v0[5] * v1[2] * v2[4] * v3[6] * v4[3] * v5[1]) + (v0[5] * v1[2] * v2[6] * v3[1] * v4[3] * v5[4]) + (-1 * v0[5] * v1[2] * v2[6] * v3[1] * v4[4] * v5[3]) + (-1 * v0[5] * v1[2] * v2[6] * v3[3] * v4[1] * v5[4]) + (v0[5] * v1[2] * v2[6] * v3[3] * v4[4] * v5[1]) + (v0[5] * v1[2] * v2[6] * v3[4] * v4[1] * v5[3]) + (-1 * v0[5] * v1[2] * v2[6] * v3[4] * v4[3] * v5[1]) + (v0[5] * v1[3] * v2[1] * v3[2] * v4[4] * v5[6]) + (-1 * v0[5] * v1[3] * v2[1] * v3[2] * v4[6] * v5[4]) + (-1 * v0[5] * v1[3] * v2[1] * v3[4] * v4[2] * v5[6]) + (v0[5] * v1[3] * v2[1] * v3[4] * v4[6] * v5[2]) + (v0[5] * v1[3] * v2[1] * v3[6] * v4[2] * v5[4]) + (-1 * v0[5] * v1[3] * v2[1] * v3[6] * v4[4] * v5[2]) + (-1 * v0[5] * v1[3] * v2[2] * v3[1] * v4[4] * v5[6]) + (v0[5] * v1[3] * v2[2] * v3[1] * v4[6] * v5[4]) + (v0[5] * v1[3] * v2[2] * v3[4] * v4[1] * v5[6]) + (-1 * v0[5] * v1[3] * v2[2] * v3[4] * v4[6] * v5[1]) + (-1 * v0[5] * v1[3] * v2[2] * v3[6] * v4[1] * v5[4]) + (v0[5] * v1[3] * v2[2] * v3[6] * v4[4] * v5[1]) + (v0[5] * v1[3] * v2[4] * v3[1] * v4[2] * v5[6]) + (-1 * v0[5] * v1[3] * v2[4] * v3[1] * v4[6] * v5[2]) + (-1 * v0[5] * v1[3] * v2[4] * v3[2] * v4[1] * v5[6]) + (v0[5] * v1[3] * v2[4] * v3[2] * v4[6] * v5[1]) + (v0[5] * v1[3] * v2[4] * v3[6] * v4[1] * v5[2]) + (-1 * v0[5] * v1[3] * v2[4] * v3[6] * v4[2] * v5[1]) + (-1 * v0[5] * v1[3] * v2[6] * v3[1] * v4[2] * v5[4]) + (v0[5] * v1[3] * v2[6] * v3[1] * v4[4] * v5[2]) + (v0[5] * v1[3] * v2[6] * v3[2] * v4[1] * v5[4]) + (-1 * v0[5] * v1[3] * v2[6] * v3[2] * v4[4] * v5[1]) + (-1 * v0[5] * v1[3] * v2[6] * v3[4] * v4[1] * v5[2]) + (v0[5] * v1[3] * v2[6] * v3[4] * v4[2] * v5[1]) + (-1 * v0[5] * v1[4] * v2[1] * v3[2] * v4[3] * v5[6]) + (v0[5] * v1[4] * v2[1] * v3[2] * v4[6] * v5[3]) + (v0[5] * v1[4] * v2[1] * v3[3] * v4[2] * v5[6]) + (-1 * v0[5] * v1[4] * v2[1] * v3[3] * v4[6] * v5[2]) + (-1 * v0[5] * v1[4] * v2[1] * v3[6] * v4[2] * v5[3]) + (v0[5] * v1[4] * v2[1] * v3[6] * v4[3] * v5[2]) + (v0[5] * v1[4] * v2[2] * v3[1] * v4[3] * v5[6]) + (-1 * v0[5] * v1[4] * v2[2] * v3[1] * v4[6] * v5[3]) + (-1 * v0[5] * v1[4] * v2[2] * v3[3] * v4[1] * v5[6]) + (v0[5] * v1[4] * v2[2] * v3[3] * v4[6] * v5[1]) + (v0[5] * v1[4] * v2[2] * v3[6] * v4[1] * v5[3]) + (-1 * v0[5] * v1[4] * v2[2] * v3[6] * v4[3] * v5[1]) + (-1 * v0[5] * v1[4] * v2[3] * v3[1] * v4[2] * v5[6]) + (v0[5] * v1[4] * v2[3] * v3[1] * v4[6] * v5[2]) + (v0[5] * v1[4] * v2[3] * v3[2] * v4[1] * v5[6]) + (-1 * v0[5] * v1[4] * v2[3] * v3[2] * v4[6] * v5[1]) + (-1 * v0[5] * v1[4] * v2[3] * v3[6] * v4[1] * v5[2]) + (v0[5] * v1[4] * v2[3] * v3[6] * v4[2] * v5[1]) + (v0[5] * v1[4] * v2[6] * v3[1] * v4[2] * v5[3]) + (-1 * v0[5] * v1[4] * v2[6] * v3[1] * v4[3] * v5[2]) + (-1 * v0[5] * v1[4] * v2[6] * v3[2] * v4[1] * v5[3]) + (v0[5] * v1[4] * v2[6] * v3[2] * v4[3] * v5[1]) + (v0[5] * v1[4] * v2[6] * v3[3] * v4[1] * v5[2]) + (-1 * v0[5] * v1[4] * v2[6] * v3[3] * v4[2] * v5[1]) + (v0[5] * v1[6] * v2[1] * v3[2] * v4[3] * v5[4]) + (-1 * v0[5] * v1[6] * v2[1] * v3[2] * v4[4] * v5[3]) + (-1 * v0[5] * v1[6] * v2[1] * v3[3] * v4[2] * v5[4]) + (v0[5] * v1[6] * v2[1] * v3[3] * v4[4] * v5[2]) + (v0[5] * v1[6] * v2[1] * v3[4] * v4[2] * v5[3]) + (-1 * v0[5] * v1[6] * v2[1] * v3[4] * v4[3] * v5[2]) + (-1 * v0[5] * v1[6] * v2[2] * v3[1] * v4[3] * v5[4]) + (v0[5] * v1[6] * v2[2] * v3[1] * v4[4] * v5[3]) + (v0[5] * v1[6] * v2[2] * v3[3] * v4[1] * v5[4]) + (-1 * v0[5] * v1[6] * v2[2] * v3[3] * v4[4] * v5[1]) + (-1 * v0[5] * v1[6] * v2[2] * v3[4] * v4[1] * v5[3]) + (v0[5] * v1[6] * v2[2] * v3[4] * v4[3] * v5[1]) + (v0[5] * v1[6] * v2[3] * v3[1] * v4[2] * v5[4]) + (-1 * v0[5] * v1[6] * v2[3] * v3[1] * v4[4] * v5[2]) + (-1 * v0[5] * v1[6] * v2[3] * v3[2] * v4[1] * v5[4]) + (v0[5] * v1[6] * v2[3] * v3[2] * v4[4] * v5[1]) + (v0[5] * v1[6] * v2[3] * v3[4] * v4[1] * v5[2]) + (-1 * v0[5] * v1[6] * v2[3] * v3[4] * v4[2] * v5[1]) + (-1 * v0[5] * v1[6] * v2[4] * v3[1] * v4[2] * v5[3]) + (v0[5] * v1[6] * v2[4] * v3[1] * v4[3] * v5[2]) + (v0[5] * v1[6] * v2[4] * v3[2] * v4[1] * v5[3]) + (-1 * v0[5] * v1[6] * v2[4] * v3[2] * v4[3] * v5[1]) + (-1 * v0[5] * v1[6] * v2[4] * v3[3] * v4[1] * v5[2]) + (v0[5] * v1[6] * v2[4] * v3[3] * v4[2] * v5[1]) + (-1 * v0[6] * v1[1] * v2[2] * v3[3] * v4[4] * v5[5]) + (v0[6] * v1[1] * v2[2] * v3[3] * v4[5] * v5[4]) + (v0[6] * v1[1] * v2[2] * v3[4] * v4[3] * v5[5]) + (-1 * v0[6] * v1[1] * v2[2] * v3[4] * v4[5] * v5[3]) + (-1 * v0[6] * v1[1] * v2[2] * v3[5] * v4[3] * v5[4]) + (v0[6] * v1[1] * v2[2] * v3[5] * v4[4] * v5[3]) + (v0[6] * v1[1] * v2[3] * v3[2] * v4[4] * v5[5]) + (-1 * v0[6] * v1[1] * v2[3] * v3[2] * v4[5] * v5[4]) + (-1 * v0[6] * v1[1] * v2[3] * v3[4] * v4[2] * v5[5]) + (v0[6] * v1[1] * v2[3] * v3[4] * v4[5] * v5[2]) + (v0[6] * v1[1] * v2[3] * v3[5] * v4[2] * v5[4]) + (-1 * v0[6] * v1[1] * v2[3] * v3[5] * v4[4] * v5[2]) + (-1 * v0[6] * v1[1] * v2[4] * v3[2] * v4[3] * v5[5]) + (v0[6] * v1[1] * v2[4] * v3[2] * v4[5] * v5[3]) + (v0[6] * v1[1] * v2[4] * v3[3] * v4[2] * v5[5]) + (-1 * v0[6] * v1[1] * v2[4] * v3[3] * v4[5] * v5[2]) + (-1 * v0[6] * v1[1] * v2[4] * v3[5] * v4[2] * v5[3]) + (v0[6] * v1[1] * v2[4] * v3[5] * v4[3] * v5[2]) + (v0[6] * v1[1] * v2[5] * v3[2] * v4[3] * v5[4]) + (-1 * v0[6] * v1[1] * v2[5] * v3[2] * v4[4] * v5[3]) + (-1 * v0[6] * v1[1] * v2[5] * v3[3] * v4[2] * v5[4]) + (v0[6] * v1[1] * v2[5] * v3[3] * v4[4] * v5[2]) + (v0[6] * v1[1] * v2[5] * v3[4] * v4[2] * v5[3]) + (-1 * v0[6] * v1[1] * v2[5] * v3[4] * v4[3] * v5[2]) + (v0[6] * v1[2] * v2[1] * v3[3] * v4[4] * v5[5]) + (-1 * v0[6] * v1[2] * v2[1] * v3[3] * v4[5] * v5[4]) + (-1 * v0[6] * v1[2] * v2[1] * v3[4] * v4[3] * v5[5]) + (v0[6] * v1[2] * v2[1] * v3[4] * v4[5] * v5[3]) + (v0[6] * v1[2] * v2[1] * v3[5] * v4[3] * v5[4]) + (-1 * v0[6] * v1[2] * v2[1] * v3[5] * v4[4] * v5[3]) + (-1 * v0[6] * v1[2] * v2[3] * v3[1] * v4[4] * v5[5]) + (v0[6] * v1[2] * v2[3] * v3[1] * v4[5] * v5[4]) + (v0[6] * v1[2] * v2[3] * v3[4] * v4[1] * v5[5]) + (-1 * v0[6] * v1[2] * v2[3] * v3[4] * v4[5] * v5[1]) + (-1 * v0[6] * v1[2] * v2[3] * v3[5] * v4[1] * v5[4]) + (v0[6] * v1[2] * v2[3] * v3[5] * v4[4] * v5[1]) + (v0[6] * v1[2] * v2[4] * v3[1] * v4[3] * v5[5]) + (-1 * v0[6] * v1[2] * v2[4] * v3[1] * v4[5] * v5[3]) + (-1 * v0[6] * v1[2] * v2[4] * v3[3] * v4[1] * v5[5]) + (v0[6] * v1[2] * v2[4] * v3[3] * v4[5] * v5[1]) + (v0[6] * v1[2] * v2[4] * v3[5] * v4[1] * v5[3]) + (-1 * v0[6] * v1[2] * v2[4] * v3[5] * v4[3] * v5[1]) + (-1 * v0[6] * v1[2] * v2[5] * v3[1] * v4[3] * v5[4]) + (v0[6] * v1[2] * v2[5] * v3[1] * v4[4] * v5[3]) + (v0[6] * v1[2] * v2[5] * v3[3] * v4[1] * v5[4]) + (-1 * v0[6] * v1[2] * v2[5] * v3[3] * v4[4] * v5[1]) + (-1 * v0[6] * v1[2] * v2[5] * v3[4] * v4[1] * v5[3]) + (v0[6] * v1[2] * v2[5] * v3[4] * v4[3] * v5[1]) + (-1 * v0[6] * v1[3] * v2[1] * v3[2] * v4[4] * v5[5]) + (v0[6] * v1[3] * v2[1] * v3[2] * v4[5] * v5[4]) + (v0[6] * v1[3] * v2[1] * v3[4] * v4[2] * v5[5]) + (-1 * v0[6] * v1[3] * v2[1] * v3[4] * v4[5] * v5[2]) + (-1 * v0[6] * v1[3] * v2[1] * v3[5] * v4[2] * v5[4]) + (v0[6] * v1[3] * v2[1] * v3[5] * v4[4] * v5[2]) + (v0[6] * v1[3] * v2[2] * v3[1] * v4[4] * v5[5]) + (-1 * v0[6] * v1[3] * v2[2] * v3[1] * v4[5] * v5[4]) + (-1 * v0[6] * v1[3] * v2[2] * v3[4] * v4[1] * v5[5]) + (v0[6] * v1[3] * v2[2] * v3[4] * v4[5] * v5[1]) + (v0[6] * v1[3] * v2[2] * v3[5] * v4[1] * v5[4]) + (-1 * v0[6] * v1[3] * v2[2] * v3[5] * v4[4] * v5[1]) + (-1 * v0[6] * v1[3] * v2[4] * v3[1] * v4[2] * v5[5]) + (v0[6] * v1[3] * v2[4] * v3[1] * v4[5] * v5[2]) + (v0[6] * v1[3] * v2[4] * v3[2] * v4[1] * v5[5]) + (-1 * v0[6] * v1[3] * v2[4] * v3[2] * v4[5] * v5[1]) + (-1 * v0[6] * v1[3] * v2[4] * v3[5] * v4[1] * v5[2]) + (v0[6] * v1[3] * v2[4] * v3[5] * v4[2] * v5[1]) + (v0[6] * v1[3] * v2[5] * v3[1] * v4[2] * v5[4]) + (-1 * v0[6] * v1[3] * v2[5] * v3[1] * v4[4] * v5[2]) + (-1 * v0[6] * v1[3] * v2[5] * v3[2] * v4[1] * v5[4]) + (v0[6] * v1[3] * v2[5] * v3[2] * v4[4] * v5[1]) + (v0[6] * v1[3] * v2[5] * v3[4] * v4[1] * v5[2]) + (-1 * v0[6] * v1[3] * v2[5] * v3[4] * v4[2] * v5[1]) + (v0[6] * v1[4] * v2[1] * v3[2] * v4[3] * v5[5]) + (-1 * v0[6] * v1[4] * v2[1] * v3[2] * v4[5] * v5[3]) + (-1 * v0[6] * v1[4] * v2[1] * v3[3] * v4[2] * v5[5]) + (v0[6] * v1[4] * v2[1] * v3[3] * v4[5] * v5[2]) + (v0[6] * v1[4] * v2[1] * v3[5] * v4[2] * v5[3]) + (-1 * v0[6] * v1[4] * v2[1] * v3[5] * v4[3] * v5[2]) + (-1 * v0[6] * v1[4] * v2[2] * v3[1] * v4[3] * v5[5]) + (v0[6] * v1[4] * v2[2] * v3[1] * v4[5] * v5[3]) + (v0[6] * v1[4] * v2[2] * v3[3] * v4[1] * v5[5]) + (-1 * v0[6] * v1[4] * v2[2] * v3[3] * v4[5] * v5[1]) + (-1 * v0[6] * v1[4] * v2[2] * v3[5] * v4[1] * v5[3]) + (v0[6] * v1[4] * v2[2] * v3[5] * v4[3] * v5[1]) + (v0[6] * v1[4] * v2[3] * v3[1] * v4[2] * v5[5]) + (-1 * v0[6] * v1[4] * v2[3] * v3[1] * v4[5] * v5[2]) + (-1 * v0[6] * v1[4] * v2[3] * v3[2] * v4[1] * v5[5]) + (v0[6] * v1[4] * v2[3] * v3[2] * v4[5] * v5[1]) + (v0[6] * v1[4] * v2[3] * v3[5] * v4[1] * v5[2]) + (-1 * v0[6] * v1[4] * v2[3] * v3[5] * v4[2] * v5[1]) + (-1 * v0[6] * v1[4] * v2[5] * v3[1] * v4[2] * v5[3]) + (v0[6] * v1[4] * v2[5] * v3[1] * v4[3] * v5[2]) + (v0[6] * v1[4] * v2[5] * v3[2] * v4[1] * v5[3]) + (-1 * v0[6] * v1[4] * v2[5] * v3[2] * v4[3] * v5[1]) + (-1 * v0[6] * v1[4] * v2[5] * v3[3] * v4[1] * v5[2]) + (v0[6] * v1[4] * v2[5] * v3[3] * v4[2] * v5[1]) + (-1 * v0[6] * v1[5] * v2[1] * v3[2] * v4[3] * v5[4]) + (v0[6] * v1[5] * v2[1] * v3[2] * v4[4] * v5[3]) + (v0[6] * v1[5] * v2[1] * v3[3] * v4[2] * v5[4]) + (-1 * v0[6] * v1[5] * v2[1] * v3[3] * v4[4] * v5[2]) + (-1 * v0[6] * v1[5] * v2[1] * v3[4] * v4[2] * v5[3]) + (v0[6] * v1[5] * v2[1] * v3[4] * v4[3] * v5[2]) + (v0[6] * v1[5] * v2[2] * v3[1] * v4[3] * v5[4]) + (-1 * v0[6] * v1[5] * v2[2] * v3[1] * v4[4] * v5[3]) + (-1 * v0[6] * v1[5] * v2[2] * v3[3] * v4[1] * v5[4]) + (v0[6] * v1[5] * v2[2] * v3[3] * v4[4] * v5[1]) + (v0[6] * v1[5] * v2[2] * v3[4] * v4[1] * v5[3]) + (-1 * v0[6] * v1[5] * v2[2] * v3[4] * v4[3] * v5[1]) + (-1 * v0[6] * v1[5] * v2[3] * v3[1] * v4[2] * v5[4]) + (v0[6] * v1[5] * v2[3] * v3[1] * v4[4] * v5[2]) + (v0[6] * v1[5] * v2[3] * v3[2] * v4[1] * v5[4]) + (-1 * v0[6] * v1[5] * v2[3] * v3[2] * v4[4] * v5[1]) + (-1 * v0[6] * v1[5] * v2[3] * v3[4] * v4[1] * v5[2]) + (v0[6] * v1[5] * v2[3] * v3[4] * v4[2] * v5[1]) + (v0[6] * v1[5] * v2[4] * v3[1] * v4[2] * v5[3]) + (-1 * v0[6] * v1[5] * v2[4] * v3[1] * v4[3] * v5[2]) + (-1 * v0[6] * v1[5] * v2[4] * v3[2] * v4[1] * v5[3]) + (v0[6] * v1[5] * v2[4] * v3[2] * v4[3] * v5[1]) + (v0[6] * v1[5] * v2[4] * v3[3] * v4[1] * v5[2]) + (-1 * v0[6] * v1[5] * v2[4] * v3[3] * v4[2] * v5[1]);
r0[1] = (-1 * v0[0] * v1[2] * v2[3] * v3[4] * v4[5] * v5[6]) + (v0[0] * v1[2] * v2[3] * v3[4] * v4[6] * v5[5]) + (v0[0] * v1[2] * v2[3] * v3[5] * v4[4] * v5[6]) + (-1 * v0[0] * v1[2] * v2[3] * v3[5] * v4[6] * v5[4]) + (-1 * v0[0] * v1[2] * v2[3] * v3[6] * v4[4] * v5[5]) + (v0[0] * v1[2] * v2[3] * v3[6] * v4[5] * v5[4]) + (v0[0] * v1[2] * v2[4] * v3[3] * v4[5] * v5[6]) + (-1 * v0[0] * v1[2] * v2[4] * v3[3] * v4[6] * v5[5]) + (-1 * v0[0] * v1[2] * v2[4] * v3[5] * v4[3] * v5[6]) + (v0[0] * v1[2] * v2[4] * v3[5] * v4[6] * v5[3]) + (v0[0] * v1[2] * v2[4] * v3[6] * v4[3] * v5[5]) + (-1 * v0[0] * v1[2] * v2[4] * v3[6] * v4[5] * v5[3]) + (-1 * v0[0] * v1[2] * v2[5] * v3[3] * v4[4] * v5[6]) + (v0[0] * v1[2] * v2[5] * v3[3] * v4[6] * v5[4]) + (v0[0] * v1[2] * v2[5] * v3[4] * v4[3] * v5[6]) + (-1 * v0[0] * v1[2] * v2[5] * v3[4] * v4[6] * v5[3]) + (-1 * v0[0] * v1[2] * v2[5] * v3[6] * v4[3] * v5[4]) + (v0[0] * v1[2] * v2[5] * v3[6] * v4[4] * v5[3]) + (v0[0] * v1[2] * v2[6] * v3[3] * v4[4] * v5[5]) + (-1 * v0[0] * v1[2] * v2[6] * v3[3] * v4[5] * v5[4]) + (-1 * v0[0] * v1[2] * v2[6] * v3[4] * v4[3] * v5[5]) + (v0[0] * v1[2] * v2[6] * v3[4] * v4[5] * v5[3]) + (v0[0] * v1[2] * v2[6] * v3[5] * v4[3] * v5[4]) + (-1 * v0[0] * v1[2] * v2[6] * v3[5] * v4[4] * v5[3]) + (v0[0] * v1[3] * v2[2] * v3[4] * v4[5] * v5[6]) + (-1 * v0[0] * v1[3] * v2[2] * v3[4] * v4[6] * v5[5]) + (-1 * v0[0] * v1[3] * v2[2] * v3[5] * v4[4] * v5[6]) + (v0[0] * v1[3] * v2[2] * v3[5] * v4[6] * v5[4]) + (v0[0] * v1[3] * v2[2] * v3[6] * v4[4] * v5[5]) + (-1 * v0[0] * v1[3] * v2[2] * v3[6] * v4[5] * v5[4]) + (-1 * v0[0] * v1[3] * v2[4] * v3[2] * v4[5] * v5[6]) + (v0[0] * v1[3] * v2[4] * v3[2] * v4[6] * v5[5]) + (v0[0] * v1[3] * v2[4] * v3[5] * v4[2] * v5[6]) + (-1 * v0[0] * v1[3] * v2[4] * v3[5] * v4[6] * v5[2]) + (-1 * v0[0] * v1[3] * v2[4] * v3[6] * v4[2] * v5[5]) + (v0[0] * v1[3] * v2[4] * v3[6] * v4[5] * v5[2]) + (v0[0] * v1[3] * v2[5] * v3[2] * v4[4] * v5[6]) + (-1 * v0[0] * v1[3] * v2[5] * v3[2] * v4[6] * v5[4]) + (-1 * v0[0] * v1[3] * v2[5] * v3[4] * v4[2] * v5[6]) + (v0[0] * v1[3] * v2[5] * v3[4] * v4[6] * v5[2]) + (v0[0] * v1[3] * v2[5] * v3[6] * v4[2] * v5[4]) + (-1 * v0[0] * v1[3] * v2[5] * v3[6] * v4[4] * v5[2]) + (-1 * v0[0] * v1[3] * v2[6] * v3[2] * v4[4] * v5[5]) + (v0[0] * v1[3] * v2[6] * v3[2] * v4[5] * v5[4]) + (v0[0] * v1[3] * v2[6] * v3[4] * v4[2] * v5[5]) + (-1 * v0[0] * v1[3] * v2[6] * v3[4] * v4[5] * v5[2]) + (-1 * v0[0] * v1[3] * v2[6] * v3[5] * v4[2] * v5[4]) + (v0[0] * v1[3] * v2[6] * v3[5] * v4[4] * v5[2]) + (-1 * v0[0] * v1[4] * v2[2] * v3[3] * v4[5] * v5[6]) + (v0[0] * v1[4] * v2[2] * v3[3] * v4[6] * v5[5]) + (v0[0] * v1[4] * v2[2] * v3[5] * v4[3] * v5[6]) + (-1 * v0[0] * v1[4] * v2[2] * v3[5] * v4[6] * v5[3]) + (-1 * v0[0] * v1[4] * v2[2] * v3[6] * v4[3] * v5[5]) + (v0[0] * v1[4] * v2[2] * v3[6] * v4[5] * v5[3]) + (v0[0] * v1[4] * v2[3] * v3[2] * v4[5] * v5[6]) + (-1 * v0[0] * v1[4] * v2[3] * v3[2] * v4[6] * v5[5]) + (-1 * v0[0] * v1[4] * v2[3] * v3[5] * v4[2] * v5[6]) + (v0[0] * v1[4] * v2[3] * v3[5] * v4[6] * v5[2]) + (v0[0] * v1[4] * v2[3] * v3[6] * v4[2] * v5[5]) + (-1 * v0[0] * v1[4] * v2[3] * v3[6] * v4[5] * v5[2]) + (-1 * v0[0] * v1[4] * v2[5] * v3[2] * v4[3] * v5[6]) + (v0[0] * v1[4] * v2[5] * v3[2] * v4[6] * v5[3]) + (v0[0] * v1[4] * v2[5] * v3[3] * v4[2] * v5[6]) + (-1 * v0[0] * v1[4] * v2[5] * v3[3] * v4[6] * v5[2]) + (-1 * v0[0] * v1[4] * v2[5] * v3[6] * v4[2] * v5[3]) + (v0[0] * v1[4] * v2[5] * v3[6] * v4[3] * v5[2]) + (v0[0] * v1[4] * v2[6] * v3[2] * v4[3] * v5[5]) + (-1 * v0[0] * v1[4] * v2[6] * v3[2] * v4[5] * v5[3]) + (-1 * v0[0] * v1[4] * v2[6] * v3[3] * v4[2] * v5[5]) + (v0[0] * v1[4] * v2[6] * v3[3] * v4[5] * v5[2]) + (v0[0] * v1[4] * v2[6] * v3[5] * v4[2] * v5[3]) + (-1 * v0[0] * v1[4] * v2[6] * v3[5] * v4[3] * v5[2]) + (v0[0] * v1[5] * v2[2] * v3[3] * v4[4] * v5[6]) + (-1 * v0[0] * v1[5] * v2[2] * v3[3] * v4[6] * v5[4]) + (-1 * v0[0] * v1[5] * v2[2] * v3[4] * v4[3] * v5[6]) + (v0[0] * v1[5] * v2[2] * v3[4] * v4[6] * v5[3]) + (v0[0] * v1[5] * v2[2] * v3[6] * v4[3] * v5[4]) + (-1 * v0[0] * v1[5] * v2[2] * v3[6] * v4[4] * v5[3]) + (-1 * v0[0] * v1[5] * v2[3] * v3[2] * v4[4] * v5[6]) + (v0[0] * v1[5] * v2[3] * v3[2] * v4[6] * v5[4]) + (v0[0] * v1[5] * v2[3] * v3[4] * v4[2] * v5[6]) + (-1 * v0[0] * v1[5] * v2[3] * v3[4] * v4[6] * v5[2]) + (-1 * v0[0] * v1[5] * v2[3] * v3[6] * v4[2] * v5[4]) + (v0[0] * v1[5] * v2[3] * v3[6] * v4[4] * v5[2]) + (v0[0] * v1[5] * v2[4] * v3[2] * v4[3] * v5[6]) + (-1 * v0[0] * v1[5] * v2[4] * v3[2] * v4[6] * v5[3]) + (-1 * v0[0] * v1[5] * v2[4] * v3[3] * v4[2] * v5[6]) + (v0[0] * v1[5] * v2[4] * v3[3] * v4[6] * v5[2]) + (v0[0] * v1[5] * v2[4] * v3[6] * v4[2] * v5[3]) + (-1 * v0[0] * v1[5] * v2[4] * v3[6] * v4[3] * v5[2]) + (-1 * v0[0] * v1[5] * v2[6] * v3[2] * v4[3] * v5[4]) + (v0[0] * v1[5] * v2[6] * v3[2] * v4[4] * v5[3]) + (v0[0] * v1[5] * v2[6] * v3[3] * v4[2] * v5[4]) + (-1 * v0[0] * v1[5] * v2[6] * v3[3] * v4[4] * v5[2]) + (-1 * v0[0] * v1[5] * v2[6] * v3[4] * v4[2] * v5[3]) + (v0[0] * v1[5] * v2[6] * v3[4] * v4[3] * v5[2]) + (-1 * v0[0] * v1[6] * v2[2] * v3[3] * v4[4] * v5[5]) + (v0[0] * v1[6] * v2[2] * v3[3] * v4[5] * v5[4]) + (v0[0] * v1[6] * v2[2] * v3[4] * v4[3] * v5[5]) + (-1 * v0[0] * v1[6] * v2[2] * v3[4] * v4[5] * v5[3]) + (-1 * v0[0] * v1[6] * v2[2] * v3[5] * v4[3] * v5[4]) + (v0[0] * v1[6] * v2[2] * v3[5] * v4[4] * v5[3]) + (v0[0] * v1[6] * v2[3] * v3[2] * v4[4] * v5[5]) + (-1 * v0[0] * v1[6] * v2[3] * v3[2] * v4[5] * v5[4]) + (-1 * v0[0] * v1[6] * v2[3] * v3[4] * v4[2] * v5[5]) + (v0[0] * v1[6] * v2[3] * v3[4] * v4[5] * v5[2]) + (v0[0] * v1[6] * v2[3] * v3[5] * v4[2] * v5[4]) + (-1 * v0[0] * v1[6] * v2[3] * v3[5] * v4[4] * v5[2]) + (-1 * v0[0] * v1[6] * v2[4] * v3[2] * v4[3] * v5[5]) + (v0[0] * v1[6] * v2[4] * v3[2] * v4[5] * v5[3]) + (v0[0] * v1[6] * v2[4] * v3[3] * v4[2] * v5[5]) + (-1 * v0[0] * v1[6] * v2[4] * v3[3] * v4[5] * v5[2]) + (-1 * v0[0] * v1[6] * v2[4] * v3[5] * v4[2] * v5[3]) + (v0[0] * v1[6] * v2[4] * v3[5] * v4[3] * v5[2]) + (v0[0] * v1[6] * v2[5] * v3[2] * v4[3] * v5[4]) + (-1 * v0[0] * v1[6] * v2[5] * v3[2] * v4[4] * v5[3]) + (-1 * v0[0] * v1[6] * v2[5] * v3[3] * v4[2] * v5[4]) + (v0[0] * v1[6] * v2[5] * v3[3] * v4[4] * v5[2]) + (v0[0] * v1[6] * v2[5] * v3[4] * v4[2] * v5[3]) + (-1 * v0[0] * v1[6] * v2[5] * v3[4] * v4[3] * v5[2]) + (v0[2] * v1[0] * v2[3] * v3[4] * v4[5] * v5[6]) + (-1 * v0[2] * v1[0] * v2[3] * v3[4] * v4[6] * v5[5]) + (-1 * v0[2] * v1[0] * v2[3] * v3[5] * v4[4] * v5[6]) + (v0[2] * v1[0] * v2[3] * v3[5] * v4[6] * v5[4]) + (v0[2] * v1[0] * v2[3] * v3[6] * v4[4] * v5[5]) + (-1 * v0[2] * v1[0] * v2[3] * v3[6] * v4[5] * v5[4]) + (-1 * v0[2] * v1[0] * v2[4] * v3[3] * v4[5] * v5[6]) + (v0[2] * v1[0] * v2[4] * v3[3] * v4[6] * v5[5]) + (v0[2] * v1[0] * v2[4] * v3[5] * v4[3] * v5[6]) + (-1 * v0[2] * v1[0] * v2[4] * v3[5] * v4[6] * v5[3]) + (-1 * v0[2] * v1[0] * v2[4] * v3[6] * v4[3] * v5[5]) + (v0[2] * v1[0] * v2[4] * v3[6] * v4[5] * v5[3]) + (v0[2] * v1[0] * v2[5] * v3[3] * v4[4] * v5[6]) + (-1 * v0[2] * v1[0] * v2[5] * v3[3] * v4[6] * v5[4]) + (-1 * v0[2] * v1[0] * v2[5] * v3[4] * v4[3] * v5[6]) + (v0[2] * v1[0] * v2[5] * v3[4] * v4[6] * v5[3]) + (v0[2] * v1[0] * v2[5] * v3[6] * v4[3] * v5[4]) + (-1 * v0[2] * v1[0] * v2[5] * v3[6] * v4[4] * v5[3]) + (-1 * v0[2] * v1[0] * v2[6] * v3[3] * v4[4] * v5[5]) + (v0[2] * v1[0] * v2[6] * v3[3] * v4[5] * v5[4]) + (v0[2] * v1[0] * v2[6] * v3[4] * v4[3] * v5[5]) + (-1 * v0[2] * v1[0] * v2[6] * v3[4] * v4[5] * v5[3]) + (-1 * v0[2] * v1[0] * v2[6] * v3[5] * v4[3] * v5[4]) + (v0[2] * v1[0] * v2[6] * v3[5] * v4[4] * v5[3]) + (-1 * v0[2] * v1[3] * v2[0] * v3[4] * v4[5] * v5[6]) + (v0[2] * v1[3] * v2[0] * v3[4] * v4[6] * v5[5]) + (v0[2] * v1[3] * v2[0] * v3[5] * v4[4] * v5[6]) + (-1 * v0[2] * v1[3] * v2[0] * v3[5] * v4[6] * v5[4]) + (-1 * v0[2] * v1[3] * v2[0] * v3[6] * v4[4] * v5[5]) + (v0[2] * v1[3] * v2[0] * v3[6] * v4[5] * v5[4]) + (v0[2] * v1[3] * v2[4] * v3[0] * v4[5] * v5[6]) + (-1 * v0[2] * v1[3] * v2[4] * v3[0] * v4[6] * v5[5]) + (-1 * v0[2] * v1[3] * v2[4] * v3[5] * v4[0] * v5[6]) + (v0[2] * v1[3] * v2[4] * v3[5] * v4[6] * v5[0]) + (v0[2] * v1[3] * v2[4] * v3[6] * v4[0] * v5[5]) + (-1 * v0[2] * v1[3] * v2[4] * v3[6] * v4[5] * v5[0]) + (-1 * v0[2] * v1[3] * v2[5] * v3[0] * v4[4] * v5[6]) + (v0[2] * v1[3] * v2[5] * v3[0] * v4[6] * v5[4]) + (v0[2] * v1[3] * v2[5] * v3[4] * v4[0] * v5[6]) + (-1 * v0[2] * v1[3] * v2[5] * v3[4] * v4[6] * v5[0]) + (-1 * v0[2] * v1[3] * v2[5] * v3[6] * v4[0] * v5[4]) + (v0[2] * v1[3] * v2[5] * v3[6] * v4[4] * v5[0]) + (v0[2] * v1[3] * v2[6] * v3[0] * v4[4] * v5[5]) + (-1 * v0[2] * v1[3] * v2[6] * v3[0] * v4[5] * v5[4]) + (-1 * v0[2] * v1[3] * v2[6] * v3[4] * v4[0] * v5[5]) + (v0[2] * v1[3] * v2[6] * v3[4] * v4[5] * v5[0]) + (v0[2] * v1[3] * v2[6] * v3[5] * v4[0] * v5[4]) + (-1 * v0[2] * v1[3] * v2[6] * v3[5] * v4[4] * v5[0]) + (v0[2] * v1[4] * v2[0] * v3[3] * v4[5] * v5[6]) + (-1 * v0[2] * v1[4] * v2[0] * v3[3] * v4[6] * v5[5]) + (-1 * v0[2] * v1[4] * v2[0] * v3[5] * v4[3] * v5[6]) + (v0[2] * v1[4] * v2[0] * v3[5] * v4[6] * v5[3]) + (v0[2] * v1[4] * v2[0] * v3[6] * v4[3] * v5[5]) + (-1 * v0[2] * v1[4] * v2[0] * v3[6] * v4[5] * v5[3]) + (-1 * v0[2] * v1[4] * v2[3] * v3[0] * v4[5] * v5[6]) + (v0[2] * v1[4] * v2[3] * v3[0] * v4[6] * v5[5]) + (v0[2] * v1[4] * v2[3] * v3[5] * v4[0] * v5[6]) + (-1 * v0[2] * v1[4] * v2[3] * v3[5] * v4[6] * v5[0]) + (-1 * v0[2] * v1[4] * v2[3] * v3[6] * v4[0] * v5[5]) + (v0[2] * v1[4] * v2[3] * v3[6] * v4[5] * v5[0]) + (v0[2] * v1[4] * v2[5] * v3[0] * v4[3] * v5[6]) + (-1 * v0[2] * v1[4] * v2[5] * v3[0] * v4[6] * v5[3]) + (-1 * v0[2] * v1[4] * v2[5] * v3[3] * v4[0] * v5[6]) + (v0[2] * v1[4] * v2[5] * v3[3] * v4[6] * v5[0]) + (v0[2] * v1[4] * v2[5] * v3[6] * v4[0] * v5[3]) + (-1 * v0[2] * v1[4] * v2[5] * v3[6] * v4[3] * v5[0]) + (-1 * v0[2] * v1[4] * v2[6] * v3[0] * v4[3] * v5[5]) + (v0[2] * v1[4] * v2[6] * v3[0] * v4[5] * v5[3]) + (v0[2] * v1[4] * v2[6] * v3[3] * v4[0] * v5[5]) + (-1 * v0[2] * v1[4] * v2[6] * v3[3] * v4[5] * v5[0]) + (-1 * v0[2] * v1[4] * v2[6] * v3[5] * v4[0] * v5[3]) + (v0[2] * v1[4] * v2[6] * v3[5] * v4[3] * v5[0]) + (-1 * v0[2] * v1[5] * v2[0] * v3[3] * v4[4] * v5[6]) + (v0[2] * v1[5] * v2[0] * v3[3] * v4[6] * v5[4]) + (v0[2] * v1[5] * v2[0] * v3[4] * v4[3] * v5[6]) + (-1 * v0[2] * v1[5] * v2[0] * v3[4] * v4[6] * v5[3]) + (-1 * v0[2] * v1[5] * v2[0] * v3[6] * v4[3] * v5[4]) + (v0[2] * v1[5] * v2[0] * v3[6] * v4[4] * v5[3]) + (v0[2] * v1[5] * v2[3] * v3[0] * v4[4] * v5[6]) + (-1 * v0[2] * v1[5] * v2[3] * v3[0] * v4[6] * v5[4]) + (-1 * v0[2] * v1[5] * v2[3] * v3[4] * v4[0] * v5[6]) + (v0[2] * v1[5] * v2[3] * v3[4] * v4[6] * v5[0]) + (v0[2] * v1[5] * v2[3] * v3[6] * v4[0] * v5[4]) + (-1 * v0[2] * v1[5] * v2[3] * v3[6] * v4[4] * v5[0]) + (-1 * v0[2] * v1[5] * v2[4] * v3[0] * v4[3] * v5[6]) + (v0[2] * v1[5] * v2[4] * v3[0] * v4[6] * v5[3]) + (v0[2] * v1[5] * v2[4] * v3[3] * v4[0] * v5[6]) + (-1 * v0[2] * v1[5] * v2[4] * v3[3] * v4[6] * v5[0]) + (-1 * v0[2] * v1[5] * v2[4] * v3[6] * v4[0] * v5[3]) + (v0[2] * v1[5] * v2[4] * v3[6] * v4[3] * v5[0]) + (v0[2] * v1[5] * v2[6] * v3[0] * v4[3] * v5[4]) + (-1 * v0[2] * v1[5] * v2[6] * v3[0] * v4[4] * v5[3]) + (-1 * v0[2] * v1[5] * v2[6] * v3[3] * v4[0] * v5[4]) + (v0[2] * v1[5] * v2[6] * v3[3] * v4[4] * v5[0]) + (v0[2] * v1[5] * v2[6] * v3[4] * v4[0] * v5[3]) + (-1 * v0[2] * v1[5] * v2[6] * v3[4] * v4[3] * v5[0]) + (v0[2] * v1[6] * v2[0] * v3[3] * v4[4] * v5[5]) + (-1 * v0[2] * v1[6] * v2[0] * v3[3] * v4[5] * v5[4]) + (-1 * v0[2] * v1[6] * v2[0] * v3[4] * v4[3] * v5[5]) + (v0[2] * v1[6] * v2[0] * v3[4] * v4[5] * v5[3]) + (v0[2] * v1[6] * v2[0] * v3[5] * v4[3] * v5[4]) + (-1 * v0[2] * v1[6] * v2[0] * v3[5] * v4[4] * v5[3]) + (-1 * v0[2] * v1[6] * v2[3] * v3[0] * v4[4] * v5[5]) + (v0[2] * v1[6] * v2[3] * v3[0] * v4[5] * v5[4]) + (v0[2] * v1[6] * v2[3] * v3[4] * v4[0] * v5[5]) + (-1 * v0[2] * v1[6] * v2[3] * v3[4] * v4[5] * v5[0]) + (-1 * v0[2] * v1[6] * v2[3] * v3[5] * v4[0] * v5[4]) + (v0[2] * v1[6] * v2[3] * v3[5] * v4[4] * v5[0]) + (v0[2] * v1[6] * v2[4] * v3[0] * v4[3] * v5[5]) + (-1 * v0[2] * v1[6] * v2[4] * v3[0] * v4[5] * v5[3]) + (-1 * v0[2] * v1[6] * v2[4] * v3[3] * v4[0] * v5[5]) + (v0[2] * v1[6] * v2[4] * v3[3] * v4[5] * v5[0]) + (v0[2] * v1[6] * v2[4] * v3[5] * v4[0] * v5[3]) + (-1 * v0[2] * v1[6] * v2[4] * v3[5] * v4[3] * v5[0]) + (-1 * v0[2] * v1[6] * v2[5] * v3[0] * v4[3] * v5[4]) + (v0[2] * v1[6] * v2[5] * v3[0] * v4[4] * v5[3]) + (v0[2] * v1[6] * v2[5] * v3[3] * v4[0] * v5[4]) + (-1 * v0[2] * v1[6] * v2[5] * v3[3] * v4[4] * v5[0]) + (-1 * v0[2] * v1[6] * v2[5] * v3[4] * v4[0] * v5[3]) + (v0[2] * v1[6] * v2[5] * v3[4] * v4[3] * v5[0]) + (-1 * v0[3] * v1[0] * v2[2] * v3[4] * v4[5] * v5[6]) + (v0[3] * v1[0] * v2[2] * v3[4] * v4[6] * v5[5]) + (v0[3] * v1[0] * v2[2] * v3[5] * v4[4] * v5[6]) + (-1 * v0[3] * v1[0] * v2[2] * v3[5] * v4[6] * v5[4]) + (-1 * v0[3] * v1[0] * v2[2] * v3[6] * v4[4] * v5[5]) + (v0[3] * v1[0] * v2[2] * v3[6] * v4[5] * v5[4]) + (v0[3] * v1[0] * v2[4] * v3[2] * v4[5] * v5[6]) + (-1 * v0[3] * v1[0] * v2[4] * v3[2] * v4[6] * v5[5]) + (-1 * v0[3] * v1[0] * v2[4] * v3[5] * v4[2] * v5[6]) + (v0[3] * v1[0] * v2[4] * v3[5] * v4[6] * v5[2]) + (v0[3] * v1[0] * v2[4] * v3[6] * v4[2] * v5[5]) + (-1 * v0[3] * v1[0] * v2[4] * v3[6] * v4[5] * v5[2]) + (-1 * v0[3] * v1[0] * v2[5] * v3[2] * v4[4] * v5[6]) + (v0[3] * v1[0] * v2[5] * v3[2] * v4[6] * v5[4]) + (v0[3] * v1[0] * v2[5] * v3[4] * v4[2] * v5[6]) + (-1 * v0[3] * v1[0] * v2[5] * v3[4] * v4[6] * v5[2]) + (-1 * v0[3] * v1[0] * v2[5] * v3[6] * v4[2] * v5[4]) + (v0[3] * v1[0] * v2[5] * v3[6] * v4[4] * v5[2]) + (v0[3] * v1[0] * v2[6] * v3[2] * v4[4] * v5[5]) + (-1 * v0[3] * v1[0] * v2[6] * v3[2] * v4[5] * v5[4]) + (-1 * v0[3] * v1[0] * v2[6] * v3[4] * v4[2] * v5[5]) + (v0[3] * v1[0] * v2[6] * v3[4] * v4[5] * v5[2]) + (v0[3] * v1[0] * v2[6] * v3[5] * v4[2] * v5[4]) + (-1 * v0[3] * v1[0] * v2[6] * v3[5] * v4[4] * v5[2]) + (v0[3] * v1[2] * v2[0] * v3[4] * v4[5] * v5[6]) + (-1 * v0[3] * v1[2] * v2[0] * v3[4] * v4[6] * v5[5]) + (-1 * v0[3] * v1[2] * v2[0] * v3[5] * v4[4] * v5[6]) + (v0[3] * v1[2] * v2[0] * v3[5] * v4[6] * v5[4]) + (v0[3] * v1[2] * v2[0] * v3[6] * v4[4] * v5[5]) + (-1 * v0[3] * v1[2] * v2[0] * v3[6] * v4[5] * v5[4]) + (-1 * v0[3] * v1[2] * v2[4] * v3[0] * v4[5] * v5[6]) + (v0[3] * v1[2] * v2[4] * v3[0] * v4[6] * v5[5]) + (v0[3] * v1[2] * v2[4] * v3[5] * v4[0] * v5[6]) + (-1 * v0[3] * v1[2] * v2[4] * v3[5] * v4[6] * v5[0]) + (-1 * v0[3] * v1[2] * v2[4] * v3[6] * v4[0] * v5[5]) + (v0[3] * v1[2] * v2[4] * v3[6] * v4[5] * v5[0]) + (v0[3] * v1[2] * v2[5] * v3[0] * v4[4] * v5[6]) + (-1 * v0[3] * v1[2] * v2[5] * v3[0] * v4[6] * v5[4]) + (-1 * v0[3] * v1[2] * v2[5] * v3[4] * v4[0] * v5[6]) + (v0[3] * v1[2] * v2[5] * v3[4] * v4[6] * v5[0]) + (v0[3] * v1[2] * v2[5] * v3[6] * v4[0] * v5[4]) + (-1 * v0[3] * v1[2] * v2[5] * v3[6] * v4[4] * v5[0]) + (-1 * v0[3] * v1[2] * v2[6] * v3[0] * v4[4] * v5[5]) + (v0[3] * v1[2] * v2[6] * v3[0] * v4[5] * v5[4]) + (v0[3] * v1[2] * v2[6] * v3[4] * v4[0] * v5[5]) + (-1 * v0[3] * v1[2] * v2[6] * v3[4] * v4[5] * v5[0]) + (-1 * v0[3] * v1[2] * v2[6] * v3[5] * v4[0] * v5[4]) + (v0[3] * v1[2] * v2[6] * v3[5] * v4[4] * v5[0]) + (-1 * v0[3] * v1[4] * v2[0] * v3[2] * v4[5] * v5[6]) + (v0[3] * v1[4] * v2[0] * v3[2] * v4[6] * v5[5]) + (v0[3] * v1[4] * v2[0] * v3[5] * v4[2] * v5[6]) + (-1 * v0[3] * v1[4] * v2[0] * v3[5] * v4[6] * v5[2]) + (-1 * v0[3] * v1[4] * v2[0] * v3[6] * v4[2] * v5[5]) + (v0[3] * v1[4] * v2[0] * v3[6] * v4[5] * v5[2]) + (v0[3] * v1[4] * v2[2] * v3[0] * v4[5] * v5[6]) + (-1 * v0[3] * v1[4] * v2[2] * v3[0] * v4[6] * v5[5]) + (-1 * v0[3] * v1[4] * v2[2] * v3[5] * v4[0] * v5[6]) + (v0[3] * v1[4] * v2[2] * v3[5] * v4[6] * v5[0]) + (v0[3] * v1[4] * v2[2] * v3[6] * v4[0] * v5[5]) + (-1 * v0[3] * v1[4] * v2[2] * v3[6] * v4[5] * v5[0]) + (-1 * v0[3] * v1[4] * v2[5] * v3[0] * v4[2] * v5[6]) + (v0[3] * v1[4] * v2[5] * v3[0] * v4[6] * v5[2]) + (v0[3] * v1[4] * v2[5] * v3[2] * v4[0] * v5[6]) + (-1 * v0[3] * v1[4] * v2[5] * v3[2] * v4[6] * v5[0]) + (-1 * v0[3] * v1[4] * v2[5] * v3[6] * v4[0] * v5[2]) + (v0[3] * v1[4] * v2[5] * v3[6] * v4[2] * v5[0]) + (v0[3] * v1[4] * v2[6] * v3[0] * v4[2] * v5[5]) + (-1 * v0[3] * v1[4] * v2[6] * v3[0] * v4[5] * v5[2]) + (-1 * v0[3] * v1[4] * v2[6] * v3[2] * v4[0] * v5[5]) + (v0[3] * v1[4] * v2[6] * v3[2] * v4[5] * v5[0]) + (v0[3] * v1[4] * v2[6] * v3[5] * v4[0] * v5[2]) + (-1 * v0[3] * v1[4] * v2[6] * v3[5] * v4[2] * v5[0]) + (v0[3] * v1[5] * v2[0] * v3[2] * v4[4] * v5[6]) + (-1 * v0[3] * v1[5] * v2[0] * v3[2] * v4[6] * v5[4]) + (-1 * v0[3] * v1[5] * v2[0] * v3[4] * v4[2] * v5[6]) + (v0[3] * v1[5] * v2[0] * v3[4] * v4[6] * v5[2]) + (v0[3] * v1[5] * v2[0] * v3[6] * v4[2] * v5[4]) + (-1 * v0[3] * v1[5] * v2[0] * v3[6] * v4[4] * v5[2]) + (-1 * v0[3] * v1[5] * v2[2] * v3[0] * v4[4] * v5[6]) + (v0[3] * v1[5] * v2[2] * v3[0] * v4[6] * v5[4]) + (v0[3] * v1[5] * v2[2] * v3[4] * v4[0] * v5[6]) + (-1 * v0[3] * v1[5] * v2[2] * v3[4] * v4[6] * v5[0]) + (-1 * v0[3] * v1[5] * v2[2] * v3[6] * v4[0] * v5[4]) + (v0[3] * v1[5] * v2[2] * v3[6] * v4[4] * v5[0]) + (v0[3] * v1[5] * v2[4] * v3[0] * v4[2] * v5[6]) + (-1 * v0[3] * v1[5] * v2[4] * v3[0] * v4[6] * v5[2]) + (-1 * v0[3] * v1[5] * v2[4] * v3[2] * v4[0] * v5[6]) + (v0[3] * v1[5] * v2[4] * v3[2] * v4[6] * v5[0]) + (v0[3] * v1[5] * v2[4] * v3[6] * v4[0] * v5[2]) + (-1 * v0[3] * v1[5] * v2[4] * v3[6] * v4[2] * v5[0]) + (-1 * v0[3] * v1[5] * v2[6] * v3[0] * v4[2] * v5[4]) + (v0[3] * v1[5] * v2[6] * v3[0] * v4[4] * v5[2]) + (v0[3] * v1[5] * v2[6] * v3[2] * v4[0] * v5[4]) + (-1 * v0[3] * v1[5] * v2[6] * v3[2] * v4[4] * v5[0]) + (-1 * v0[3] * v1[5] * v2[6] * v3[4] * v4[0] * v5[2]) + (v0[3] * v1[5] * v2[6] * v3[4] * v4[2] * v5[0]) + (-1 * v0[3] * v1[6] * v2[0] * v3[2] * v4[4] * v5[5]) + (v0[3] * v1[6] * v2[0] * v3[2] * v4[5] * v5[4]) + (v0[3] * v1[6] * v2[0] * v3[4] * v4[2] * v5[5]) + (-1 * v0[3] * v1[6] * v2[0] * v3[4] * v4[5] * v5[2]) + (-1 * v0[3] * v1[6] * v2[0] * v3[5] * v4[2] * v5[4]) + (v0[3] * v1[6] * v2[0] * v3[5] * v4[4] * v5[2]) + (v0[3] * v1[6] * v2[2] * v3[0] * v4[4] * v5[5]) + (-1 * v0[3] * v1[6] * v2[2] * v3[0] * v4[5] * v5[4]) + (-1 * v0[3] * v1[6] * v2[2] * v3[4] * v4[0] * v5[5]) + (v0[3] * v1[6] * v2[2] * v3[4] * v4[5] * v5[0]) + (v0[3] * v1[6] * v2[2] * v3[5] * v4[0] * v5[4]) + (-1 * v0[3] * v1[6] * v2[2] * v3[5] * v4[4] * v5[0]) + (-1 * v0[3] * v1[6] * v2[4] * v3[0] * v4[2] * v5[5]) + (v0[3] * v1[6] * v2[4] * v3[0] * v4[5] * v5[2]) + (v0[3] * v1[6] * v2[4] * v3[2] * v4[0] * v5[5]) + (-1 * v0[3] * v1[6] * v2[4] * v3[2] * v4[5] * v5[0]) + (-1 * v0[3] * v1[6] * v2[4] * v3[5] * v4[0] * v5[2]) + (v0[3] * v1[6] * v2[4] * v3[5] * v4[2] * v5[0]) + (v0[3] * v1[6] * v2[5] * v3[0] * v4[2] * v5[4]) + (-1 * v0[3] * v1[6] * v2[5] * v3[0] * v4[4] * v5[2]) + (-1 * v0[3] * v1[6] * v2[5] * v3[2] * v4[0] * v5[4]) + (v0[3] * v1[6] * v2[5] * v3[2] * v4[4] * v5[0]) + (v0[3] * v1[6] * v2[5] * v3[4] * v4[0] * v5[2]) + (-1 * v0[3] * v1[6] * v2[5] * v3[4] * v4[2] * v5[0]) + (v0[4] * v1[0] * v2[2] * v3[3] * v4[5] * v5[6]) + (-1 * v0[4] * v1[0] * v2[2] * v3[3] * v4[6] * v5[5]) + (-1 * v0[4] * v1[0] * v2[2] * v3[5] * v4[3] * v5[6]) + (v0[4] * v1[0] * v2[2] * v3[5] * v4[6] * v5[3]) + (v0[4] * v1[0] * v2[2] * v3[6] * v4[3] * v5[5]) + (-1 * v0[4] * v1[0] * v2[2] * v3[6] * v4[5] * v5[3]) + (-1 * v0[4] * v1[0] * v2[3] * v3[2] * v4[5] * v5[6]) + (v0[4] * v1[0] * v2[3] * v3[2] * v4[6] * v5[5]) + (v0[4] * v1[0] * v2[3] * v3[5] * v4[2] * v5[6]) + (-1 * v0[4] * v1[0] * v2[3] * v3[5] * v4[6] * v5[2]) + (-1 * v0[4] * v1[0] * v2[3] * v3[6] * v4[2] * v5[5]) + (v0[4] * v1[0] * v2[3] * v3[6] * v4[5] * v5[2]) + (v0[4] * v1[0] * v2[5] * v3[2] * v4[3] * v5[6]) + (-1 * v0[4] * v1[0] * v2[5] * v3[2] * v4[6] * v5[3]) + (-1 * v0[4] * v1[0] * v2[5] * v3[3] * v4[2] * v5[6]) + (v0[4] * v1[0] * v2[5] * v3[3] * v4[6] * v5[2]) + (v0[4] * v1[0] * v2[5] * v3[6] * v4[2] * v5[3]) + (-1 * v0[4] * v1[0] * v2[5] * v3[6] * v4[3] * v5[2]) + (-1 * v0[4] * v1[0] * v2[6] * v3[2] * v4[3] * v5[5]) + (v0[4] * v1[0] * v2[6] * v3[2] * v4[5] * v5[3]) + (v0[4] * v1[0] * v2[6] * v3[3] * v4[2] * v5[5]) + (-1 * v0[4] * v1[0] * v2[6] * v3[3] * v4[5] * v5[2]) + (-1 * v0[4] * v1[0] * v2[6] * v3[5] * v4[2] * v5[3]) + (v0[4] * v1[0] * v2[6] * v3[5] * v4[3] * v5[2]) + (-1 * v0[4] * v1[2] * v2[0] * v3[3] * v4[5] * v5[6]) + (v0[4] * v1[2] * v2[0] * v3[3] * v4[6] * v5[5]) + (v0[4] * v1[2] * v2[0] * v3[5] * v4[3] * v5[6]) + (-1 * v0[4] * v1[2] * v2[0] * v3[5] * v4[6] * v5[3]) + (-1 * v0[4] * v1[2] * v2[0] * v3[6] * v4[3] * v5[5]) + (v0[4] * v1[2] * v2[0] * v3[6] * v4[5] * v5[3]) + (v0[4] * v1[2] * v2[3] * v3[0] * v4[5] * v5[6]) + (-1 * v0[4] * v1[2] * v2[3] * v3[0] * v4[6] * v5[5]) + (-1 * v0[4] * v1[2] * v2[3] * v3[5] * v4[0] * v5[6]) + (v0[4] * v1[2] * v2[3] * v3[5] * v4[6] * v5[0]) + (v0[4] * v1[2] * v2[3] * v3[6] * v4[0] * v5[5]) + (-1 * v0[4] * v1[2] * v2[3] * v3[6] * v4[5] * v5[0]) + (-1 * v0[4] * v1[2] * v2[5] * v3[0] * v4[3] * v5[6]) + (v0[4] * v1[2] * v2[5] * v3[0] * v4[6] * v5[3]) + (v0[4] * v1[2] * v2[5] * v3[3] * v4[0] * v5[6]) + (-1 * v0[4] * v1[2] * v2[5] * v3[3] * v4[6] * v5[0]) + (-1 * v0[4] * v1[2] * v2[5] * v3[6] * v4[0] * v5[3]) + (v0[4] * v1[2] * v2[5] * v3[6] * v4[3] * v5[0]) + (v0[4] * v1[2] * v2[6] * v3[0] * v4[3] * v5[5]) + (-1 * v0[4] * v1[2] * v2[6] * v3[0] * v4[5] * v5[3]) + (-1 * v0[4] * v1[2] * v2[6] * v3[3] * v4[0] * v5[5]) + (v0[4] * v1[2] * v2[6] * v3[3] * v4[5] * v5[0]) + (v0[4] * v1[2] * v2[6] * v3[5] * v4[0] * v5[3]) + (-1 * v0[4] * v1[2] * v2[6] * v3[5] * v4[3] * v5[0]) + (v0[4] * v1[3] * v2[0] * v3[2] * v4[5] * v5[6]) + (-1 * v0[4] * v1[3] * v2[0] * v3[2] * v4[6] * v5[5]) + (-1 * v0[4] * v1[3] * v2[0] * v3[5] * v4[2] * v5[6]) + (v0[4] * v1[3] * v2[0] * v3[5] * v4[6] * v5[2]) + (v0[4] * v1[3] * v2[0] * v3[6] * v4[2] * v5[5]) + (-1 * v0[4] * v1[3] * v2[0] * v3[6] * v4[5] * v5[2]) + (-1 * v0[4] * v1[3] * v2[2] * v3[0] * v4[5] * v5[6]) + (v0[4] * v1[3] * v2[2] * v3[0] * v4[6] * v5[5]) + (v0[4] * v1[3] * v2[2] * v3[5] * v4[0] * v5[6]) + (-1 * v0[4] * v1[3] * v2[2] * v3[5] * v4[6] * v5[0]) + (-1 * v0[4] * v1[3] * v2[2] * v3[6] * v4[0] * v5[5]) + (v0[4] * v1[3] * v2[2] * v3[6] * v4[5] * v5[0]) + (v0[4] * v1[3] * v2[5] * v3[0] * v4[2] * v5[6]) + (-1 * v0[4] * v1[3] * v2[5] * v3[0] * v4[6] * v5[2]) + (-1 * v0[4] * v1[3] * v2[5] * v3[2] * v4[0] * v5[6]) + (v0[4] * v1[3] * v2[5] * v3[2] * v4[6] * v5[0]) + (v0[4] * v1[3] * v2[5] * v3[6] * v4[0] * v5[2]) + (-1 * v0[4] * v1[3] * v2[5] * v3[6] * v4[2] * v5[0]) + (-1 * v0[4] * v1[3] * v2[6] * v3[0] * v4[2] * v5[5]) + (v0[4] * v1[3] * v2[6] * v3[0] * v4[5] * v5[2]) + (v0[4] * v1[3] * v2[6] * v3[2] * v4[0] * v5[5]) + (-1 * v0[4] * v1[3] * v2[6] * v3[2] * v4[5] * v5[0]) + (-1 * v0[4] * v1[3] * v2[6] * v3[5] * v4[0] * v5[2]) + (v0[4] * v1[3] * v2[6] * v3[5] * v4[2] * v5[0]) + (-1 * v0[4] * v1[5] * v2[0] * v3[2] * v4[3] * v5[6]) + (v0[4] * v1[5] * v2[0] * v3[2] * v4[6] * v5[3]) + (v0[4] * v1[5] * v2[0] * v3[3] * v4[2] * v5[6]) + (-1 * v0[4] * v1[5] * v2[0] * v3[3] * v4[6] * v5[2]) + (-1 * v0[4] * v1[5] * v2[0] * v3[6] * v4[2] * v5[3]) + (v0[4] * v1[5] * v2[0] * v3[6] * v4[3] * v5[2]) + (v0[4] * v1[5] * v2[2] * v3[0] * v4[3] * v5[6]) + (-1 * v0[4] * v1[5] * v2[2] * v3[0] * v4[6] * v5[3]) + (-1 * v0[4] * v1[5] * v2[2] * v3[3] * v4[0] * v5[6]) + (v0[4] * v1[5] * v2[2] * v3[3] * v4[6] * v5[0]) + (v0[4] * v1[5] * v2[2] * v3[6] * v4[0] * v5[3]) + (-1 * v0[4] * v1[5] * v2[2] * v3[6] * v4[3] * v5[0]) + (-1 * v0[4] * v1[5] * v2[3] * v3[0] * v4[2] * v5[6]) + (v0[4] * v1[5] * v2[3] * v3[0] * v4[6] * v5[2]) + (v0[4] * v1[5] * v2[3] * v3[2] * v4[0] * v5[6]) + (-1 * v0[4] * v1[5] * v2[3] * v3[2] * v4[6] * v5[0]) + (-1 * v0[4] * v1[5] * v2[3] * v3[6] * v4[0] * v5[2]) + (v0[4] * v1[5] * v2[3] * v3[6] * v4[2] * v5[0]) + (v0[4] * v1[5] * v2[6] * v3[0] * v4[2] * v5[3]) + (-1 * v0[4] * v1[5] * v2[6] * v3[0] * v4[3] * v5[2]) + (-1 * v0[4] * v1[5] * v2[6] * v3[2] * v4[0] * v5[3]) + (v0[4] * v1[5] * v2[6] * v3[2] * v4[3] * v5[0]) + (v0[4] * v1[5] * v2[6] * v3[3] * v4[0] * v5[2]) + (-1 * v0[4] * v1[5] * v2[6] * v3[3] * v4[2] * v5[0]) + (v0[4] * v1[6] * v2[0] * v3[2] * v4[3] * v5[5]) + (-1 * v0[4] * v1[6] * v2[0] * v3[2] * v4[5] * v5[3]) + (-1 * v0[4] * v1[6] * v2[0] * v3[3] * v4[2] * v5[5]) + (v0[4] * v1[6] * v2[0] * v3[3] * v4[5] * v5[2]) + (v0[4] * v1[6] * v2[0] * v3[5] * v4[2] * v5[3]) + (-1 * v0[4] * v1[6] * v2[0] * v3[5] * v4[3] * v5[2]) + (-1 * v0[4] * v1[6] * v2[2] * v3[0] * v4[3] * v5[5]) + (v0[4] * v1[6] * v2[2] * v3[0] * v4[5] * v5[3]) + (v0[4] * v1[6] * v2[2] * v3[3] * v4[0] * v5[5]) + (-1 * v0[4] * v1[6] * v2[2] * v3[3] * v4[5] * v5[0]) + (-1 * v0[4] * v1[6] * v2[2] * v3[5] * v4[0] * v5[3]) + (v0[4] * v1[6] * v2[2] * v3[5] * v4[3] * v5[0]) + (v0[4] * v1[6] * v2[3] * v3[0] * v4[2] * v5[5]) + (-1 * v0[4] * v1[6] * v2[3] * v3[0] * v4[5] * v5[2]) + (-1 * v0[4] * v1[6] * v2[3] * v3[2] * v4[0] * v5[5]) + (v0[4] * v1[6] * v2[3] * v3[2] * v4[5] * v5[0]) + (v0[4] * v1[6] * v2[3] * v3[5] * v4[0] * v5[2]) + (-1 * v0[4] * v1[6] * v2[3] * v3[5] * v4[2] * v5[0]) + (-1 * v0[4] * v1[6] * v2[5] * v3[0] * v4[2] * v5[3]) + (v0[4] * v1[6] * v2[5] * v3[0] * v4[3] * v5[2]) + (v0[4] * v1[6] * v2[5] * v3[2] * v4[0] * v5[3]) + (-1 * v0[4] * v1[6] * v2[5] * v3[2] * v4[3] * v5[0]) + (-1 * v0[4] * v1[6] * v2[5] * v3[3] * v4[0] * v5[2]) + (v0[4] * v1[6] * v2[5] * v3[3] * v4[2] * v5[0]) + (-1 * v0[5] * v1[0] * v2[2] * v3[3] * v4[4] * v5[6]) + (v0[5] * v1[0] * v2[2] * v3[3] * v4[6] * v5[4]) + (v0[5] * v1[0] * v2[2] * v3[4] * v4[3] * v5[6]) + (-1 * v0[5] * v1[0] * v2[2] * v3[4] * v4[6] * v5[3]) + (-1 * v0[5] * v1[0] * v2[2] * v3[6] * v4[3] * v5[4]) + (v0[5] * v1[0] * v2[2] * v3[6] * v4[4] * v5[3]) + (v0[5] * v1[0] * v2[3] * v3[2] * v4[4] * v5[6]) + (-1 * v0[5] * v1[0] * v2[3] * v3[2] * v4[6] * v5[4]) + (-1 * v0[5] * v1[0] * v2[3] * v3[4] * v4[2] * v5[6]) + (v0[5] * v1[0] * v2[3] * v3[4] * v4[6] * v5[2]) + (v0[5] * v1[0] * v2[3] * v3[6] * v4[2] * v5[4]) + (-1 * v0[5] * v1[0] * v2[3] * v3[6] * v4[4] * v5[2]) + (-1 * v0[5] * v1[0] * v2[4] * v3[2] * v4[3] * v5[6]) + (v0[5] * v1[0] * v2[4] * v3[2] * v4[6] * v5[3]) + (v0[5] * v1[0] * v2[4] * v3[3] * v4[2] * v5[6]) + (-1 * v0[5] * v1[0] * v2[4] * v3[3] * v4[6] * v5[2]) + (-1 * v0[5] * v1[0] * v2[4] * v3[6] * v4[2] * v5[3]) + (v0[5] * v1[0] * v2[4] * v3[6] * v4[3] * v5[2]) + (v0[5] * v1[0] * v2[6] * v3[2] * v4[3] * v5[4]) + (-1 * v0[5] * v1[0] * v2[6] * v3[2] * v4[4] * v5[3]) + (-1 * v0[5] * v1[0] * v2[6] * v3[3] * v4[2] * v5[4]) + (v0[5] * v1[0] * v2[6] * v3[3] * v4[4] * v5[2]) + (v0[5] * v1[0] * v2[6] * v3[4] * v4[2] * v5[3]) + (-1 * v0[5] * v1[0] * v2[6] * v3[4] * v4[3] * v5[2]) + (v0[5] * v1[2] * v2[0] * v3[3] * v4[4] * v5[6]) + (-1 * v0[5] * v1[2] * v2[0] * v3[3] * v4[6] * v5[4]) + (-1 * v0[5] * v1[2] * v2[0] * v3[4] * v4[3] * v5[6]) + (v0[5] * v1[2] * v2[0] * v3[4] * v4[6] * v5[3]) + (v0[5] * v1[2] * v2[0] * v3[6] * v4[3] * v5[4]) + (-1 * v0[5] * v1[2] * v2[0] * v3[6] * v4[4] * v5[3]) + (-1 * v0[5] * v1[2] * v2[3] * v3[0] * v4[4] * v5[6]) + (v0[5] * v1[2] * v2[3] * v3[0] * v4[6] * v5[4]) + (v0[5] * v1[2] * v2[3] * v3[4] * v4[0] * v5[6]) + (-1 * v0[5] * v1[2] * v2[3] * v3[4] * v4[6] * v5[0]) + (-1 * v0[5] * v1[2] * v2[3] * v3[6] * v4[0] * v5[4]) + (v0[5] * v1[2] * v2[3] * v3[6] * v4[4] * v5[0]) + (v0[5] * v1[2] * v2[4] * v3[0] * v4[3] * v5[6]) + (-1 * v0[5] * v1[2] * v2[4] * v3[0] * v4[6] * v5[3]) + (-1 * v0[5] * v1[2] * v2[4] * v3[3] * v4[0] * v5[6]) + (v0[5] * v1[2] * v2[4] * v3[3] * v4[6] * v5[0]) + (v0[5] * v1[2] * v2[4] * v3[6] * v4[0] * v5[3]) + (-1 * v0[5] * v1[2] * v2[4] * v3[6] * v4[3] * v5[0]) + (-1 * v0[5] * v1[2] * v2[6] * v3[0] * v4[3] * v5[4]) + (v0[5] * v1[2] * v2[6] * v3[0] * v4[4] * v5[3]) + (v0[5] * v1[2] * v2[6] * v3[3] * v4[0] * v5[4]) + (-1 * v0[5] * v1[2] * v2[6] * v3[3] * v4[4] * v5[0]) + (-1 * v0[5] * v1[2] * v2[6] * v3[4] * v4[0] * v5[3]) + (v0[5] * v1[2] * v2[6] * v3[4] * v4[3] * v5[0]) + (-1 * v0[5] * v1[3] * v2[0] * v3[2] * v4[4] * v5[6]) + (v0[5] * v1[3] * v2[0] * v3[2] * v4[6] * v5[4]) + (v0[5] * v1[3] * v2[0] * v3[4] * v4[2] * v5[6]) + (-1 * v0[5] * v1[3] * v2[0] * v3[4] * v4[6] * v5[2]) + (-1 * v0[5] * v1[3] * v2[0] * v3[6] * v4[2] * v5[4]) + (v0[5] * v1[3] * v2[0] * v3[6] * v4[4] * v5[2]) + (v0[5] * v1[3] * v2[2] * v3[0] * v4[4] * v5[6]) + (-1 * v0[5] * v1[3] * v2[2] * v3[0] * v4[6] * v5[4]) + (-1 * v0[5] * v1[3] * v2[2] * v3[4] * v4[0] * v5[6]) + (v0[5] * v1[3] * v2[2] * v3[4] * v4[6] * v5[0]) + (v0[5] * v1[3] * v2[2] * v3[6] * v4[0] * v5[4]) + (-1 * v0[5] * v1[3] * v2[2] * v3[6] * v4[4] * v5[0]) + (-1 * v0[5] * v1[3] * v2[4] * v3[0] * v4[2] * v5[6]) + (v0[5] * v1[3] * v2[4] * v3[0] * v4[6] * v5[2]) + (v0[5] * v1[3] * v2[4] * v3[2] * v4[0] * v5[6]) + (-1 * v0[5] * v1[3] * v2[4] * v3[2] * v4[6] * v5[0]) + (-1 * v0[5] * v1[3] * v2[4] * v3[6] * v4[0] * v5[2]) + (v0[5] * v1[3] * v2[4] * v3[6] * v4[2] * v5[0]) + (v0[5] * v1[3] * v2[6] * v3[0] * v4[2] * v5[4]) + (-1 * v0[5] * v1[3] * v2[6] * v3[0] * v4[4] * v5[2]) + (-1 * v0[5] * v1[3] * v2[6] * v3[2] * v4[0] * v5[4]) + (v0[5] * v1[3] * v2[6] * v3[2] * v4[4] * v5[0]) + (v0[5] * v1[3] * v2[6] * v3[4] * v4[0] * v5[2]) + (-1 * v0[5] * v1[3] * v2[6] * v3[4] * v4[2] * v5[0]) + (v0[5] * v1[4] * v2[0] * v3[2] * v4[3] * v5[6]) + (-1 * v0[5] * v1[4] * v2[0] * v3[2] * v4[6] * v5[3]) + (-1 * v0[5] * v1[4] * v2[0] * v3[3] * v4[2] * v5[6]) + (v0[5] * v1[4] * v2[0] * v3[3] * v4[6] * v5[2]) + (v0[5] * v1[4] * v2[0] * v3[6] * v4[2] * v5[3]) + (-1 * v0[5] * v1[4] * v2[0] * v3[6] * v4[3] * v5[2]) + (-1 * v0[5] * v1[4] * v2[2] * v3[0] * v4[3] * v5[6]) + (v0[5] * v1[4] * v2[2] * v3[0] * v4[6] * v5[3]) + (v0[5] * v1[4] * v2[2] * v3[3] * v4[0] * v5[6]) + (-1 * v0[5] * v1[4] * v2[2] * v3[3] * v4[6] * v5[0]) + (-1 * v0[5] * v1[4] * v2[2] * v3[6] * v4[0] * v5[3]) + (v0[5] * v1[4] * v2[2] * v3[6] * v4[3] * v5[0]) + (v0[5] * v1[4] * v2[3] * v3[0] * v4[2] * v5[6]) + (-1 * v0[5] * v1[4] * v2[3] * v3[0] * v4[6] * v5[2]) + (-1 * v0[5] * v1[4] * v2[3] * v3[2] * v4[0] * v5[6]) + (v0[5] * v1[4] * v2[3] * v3[2] * v4[6] * v5[0]) + (v0[5] * v1[4] * v2[3] * v3[6] * v4[0] * v5[2]) + (-1 * v0[5] * v1[4] * v2[3] * v3[6] * v4[2] * v5[0]) + (-1 * v0[5] * v1[4] * v2[6] * v3[0] * v4[2] * v5[3]) + (v0[5] * v1[4] * v2[6] * v3[0] * v4[3] * v5[2]) + (v0[5] * v1[4] * v2[6] * v3[2] * v4[0] * v5[3]) + (-1 * v0[5] * v1[4] * v2[6] * v3[2] * v4[3] * v5[0]) + (-1 * v0[5] * v1[4] * v2[6] * v3[3] * v4[0] * v5[2]) + (v0[5] * v1[4] * v2[6] * v3[3] * v4[2] * v5[0]) + (-1 * v0[5] * v1[6] * v2[0] * v3[2] * v4[3] * v5[4]) + (v0[5] * v1[6] * v2[0] * v3[2] * v4[4] * v5[3]) + (v0[5] * v1[6] * v2[0] * v3[3] * v4[2] * v5[4]) + (-1 * v0[5] * v1[6] * v2[0] * v3[3] * v4[4] * v5[2]) + (-1 * v0[5] * v1[6] * v2[0] * v3[4] * v4[2] * v5[3]) + (v0[5] * v1[6] * v2[0] * v3[4] * v4[3] * v5[2]) + (v0[5] * v1[6] * v2[2] * v3[0] * v4[3] * v5[4]) + (-1 * v0[5] * v1[6] * v2[2] * v3[0] * v4[4] * v5[3]) + (-1 * v0[5] * v1[6] * v2[2] * v3[3] * v4[0] * v5[4]) + (v0[5] * v1[6] * v2[2] * v3[3] * v4[4] * v5[0]) + (v0[5] * v1[6] * v2[2] * v3[4] * v4[0] * v5[3]) + (-1 * v0[5] * v1[6] * v2[2] * v3[4] * v4[3] * v5[0]) + (-1 * v0[5] * v1[6] * v2[3] * v3[0] * v4[2] * v5[4]) + (v0[5] * v1[6] * v2[3] * v3[0] * v4[4] * v5[2]) + (v0[5] * v1[6] * v2[3] * v3[2] * v4[0] * v5[4]) + (-1 * v0[5] * v1[6] * v2[3] * v3[2] * v4[4] * v5[0]) + (-1 * v0[5] * v1[6] * v2[3] * v3[4] * v4[0] * v5[2]) + (v0[5] * v1[6] * v2[3] * v3[4] * v4[2] * v5[0]) + (v0[5] * v1[6] * v2[4] * v3[0] * v4[2] * v5[3]) + (-1 * v0[5] * v1[6] * v2[4] * v3[0] * v4[3] * v5[2]) + (-1 * v0[5] * v1[6] * v2[4] * v3[2] * v4[0] * v5[3]) + (v0[5] * v1[6] * v2[4] * v3[2] * v4[3] * v5[0]) + (v0[5] * v1[6] * v2[4] * v3[3] * v4[0] * v5[2]) + (-1 * v0[5] * v1[6] * v2[4] * v3[3] * v4[2] * v5[0]) + (v0[6] * v1[0] * v2[2] * v3[3] * v4[4] * v5[5]) + (-1 * v0[6] * v1[0] * v2[2] * v3[3] * v4[5] * v5[4]) + (-1 * v0[6] * v1[0] * v2[2] * v3[4] * v4[3] * v5[5]) + (v0[6] * v1[0] * v2[2] * v3[4] * v4[5] * v5[3]) + (v0[6] * v1[0] * v2[2] * v3[5] * v4[3] * v5[4]) + (-1 * v0[6] * v1[0] * v2[2] * v3[5] * v4[4] * v5[3]) + (-1 * v0[6] * v1[0] * v2[3] * v3[2] * v4[4] * v5[5]) + (v0[6] * v1[0] * v2[3] * v3[2] * v4[5] * v5[4]) + (v0[6] * v1[0] * v2[3] * v3[4] * v4[2] * v5[5]) + (-1 * v0[6] * v1[0] * v2[3] * v3[4] * v4[5] * v5[2]) + (-1 * v0[6] * v1[0] * v2[3] * v3[5] * v4[2] * v5[4]) + (v0[6] * v1[0] * v2[3] * v3[5] * v4[4] * v5[2]) + (v0[6] * v1[0] * v2[4] * v3[2] * v4[3] * v5[5]) + (-1 * v0[6] * v1[0] * v2[4] * v3[2] * v4[5] * v5[3]) + (-1 * v0[6] * v1[0] * v2[4] * v3[3] * v4[2] * v5[5]) + (v0[6] * v1[0] * v2[4] * v3[3] * v4[5] * v5[2]) + (v0[6] * v1[0] * v2[4] * v3[5] * v4[2] * v5[3]) + (-1 * v0[6] * v1[0] * v2[4] * v3[5] * v4[3] * v5[2]) + (-1 * v0[6] * v1[0] * v2[5] * v3[2] * v4[3] * v5[4]) + (v0[6] * v1[0] * v2[5] * v3[2] * v4[4] * v5[3]) + (v0[6] * v1[0] * v2[5] * v3[3] * v4[2] * v5[4]) + (-1 * v0[6] * v1[0] * v2[5] * v3[3] * v4[4] * v5[2]) + (-1 * v0[6] * v1[0] * v2[5] * v3[4] * v4[2] * v5[3]) + (v0[6] * v1[0] * v2[5] * v3[4] * v4[3] * v5[2]) + (-1 * v0[6] * v1[2] * v2[0] * v3[3] * v4[4] * v5[5]) + (v0[6] * v1[2] * v2[0] * v3[3] * v4[5] * v5[4]) + (v0[6] * v1[2] * v2[0] * v3[4] * v4[3] * v5[5]) + (-1 * v0[6] * v1[2] * v2[0] * v3[4] * v4[5] * v5[3]) + (-1 * v0[6] * v1[2] * v2[0] * v3[5] * v4[3] * v5[4]) + (v0[6] * v1[2] * v2[0] * v3[5] * v4[4] * v5[3]) + (v0[6] * v1[2] * v2[3] * v3[0] * v4[4] * v5[5]) + (-1 * v0[6] * v1[2] * v2[3] * v3[0] * v4[5] * v5[4]) + (-1 * v0[6] * v1[2] * v2[3] * v3[4] * v4[0] * v5[5]) + (v0[6] * v1[2] * v2[3] * v3[4] * v4[5] * v5[0]) + (v0[6] * v1[2] * v2[3] * v3[5] * v4[0] * v5[4]) + (-1 * v0[6] * v1[2] * v2[3] * v3[5] * v4[4] * v5[0]) + (-1 * v0[6] * v1[2] * v2[4] * v3[0] * v4[3] * v5[5]) + (v0[6] * v1[2] * v2[4] * v3[0] * v4[5] * v5[3]) + (v0[6] * v1[2] * v2[4] * v3[3] * v4[0] * v5[5]) + (-1 * v0[6] * v1[2] * v2[4] * v3[3] * v4[5] * v5[0]) + (-1 * v0[6] * v1[2] * v2[4] * v3[5] * v4[0] * v5[3]) + (v0[6] * v1[2] * v2[4] * v3[5] * v4[3] * v5[0]) + (v0[6] * v1[2] * v2[5] * v3[0] * v4[3] * v5[4]) + (-1 * v0[6] * v1[2] * v2[5] * v3[0] * v4[4] * v5[3]) + (-1 * v0[6] * v1[2] * v2[5] * v3[3] * v4[0] * v5[4]) + (v0[6] * v1[2] * v2[5] * v3[3] * v4[4] * v5[0]) + (v0[6] * v1[2] * v2[5] * v3[4] * v4[0] * v5[3]) + (-1 * v0[6] * v1[2] * v2[5] * v3[4] * v4[3] * v5[0]) + (v0[6] * v1[3] * v2[0] * v3[2] * v4[4] * v5[5]) + (-1 * v0[6] * v1[3] * v2[0] * v3[2] * v4[5] * v5[4]) + (-1 * v0[6] * v1[3] * v2[0] * v3[4] * v4[2] * v5[5]) + (v0[6] * v1[3] * v2[0] * v3[4] * v4[5] * v5[2]) + (v0[6] * v1[3] * v2[0] * v3[5] * v4[2] * v5[4]) + (-1 * v0[6] * v1[3] * v2[0] * v3[5] * v4[4] * v5[2]) + (-1 * v0[6] * v1[3] * v2[2] * v3[0] * v4[4] * v5[5]) + (v0[6] * v1[3] * v2[2] * v3[0] * v4[5] * v5[4]) + (v0[6] * v1[3] * v2[2] * v3[4] * v4[0] * v5[5]) + (-1 * v0[6] * v1[3] * v2[2] * v3[4] * v4[5] * v5[0]) + (-1 * v0[6] * v1[3] * v2[2] * v3[5] * v4[0] * v5[4]) + (v0[6] * v1[3] * v2[2] * v3[5] * v4[4] * v5[0]) + (v0[6] * v1[3] * v2[4] * v3[0] * v4[2] * v5[5]) + (-1 * v0[6] * v1[3] * v2[4] * v3[0] * v4[5] * v5[2]) + (-1 * v0[6] * v1[3] * v2[4] * v3[2] * v4[0] * v5[5]) + (v0[6] * v1[3] * v2[4] * v3[2] * v4[5] * v5[0]) + (v0[6] * v1[3] * v2[4] * v3[5] * v4[0] * v5[2]) + (-1 * v0[6] * v1[3] * v2[4] * v3[5] * v4[2] * v5[0]) + (-1 * v0[6] * v1[3] * v2[5] * v3[0] * v4[2] * v5[4]) + (v0[6] * v1[3] * v2[5] * v3[0] * v4[4] * v5[2]) + (v0[6] * v1[3] * v2[5] * v3[2] * v4[0] * v5[4]) + (-1 * v0[6] * v1[3] * v2[5] * v3[2] * v4[4] * v5[0]) + (-1 * v0[6] * v1[3] * v2[5] * v3[4] * v4[0] * v5[2]) + (v0[6] * v1[3] * v2[5] * v3[4] * v4[2] * v5[0]) + (-1 * v0[6] * v1[4] * v2[0] * v3[2] * v4[3] * v5[5]) + (v0[6] * v1[4] * v2[0] * v3[2] * v4[5] * v5[3]) + (v0[6] * v1[4] * v2[0] * v3[3] * v4[2] * v5[5]) + (-1 * v0[6] * v1[4] * v2[0] * v3[3] * v4[5] * v5[2]) + (-1 * v0[6] * v1[4] * v2[0] * v3[5] * v4[2] * v5[3]) + (v0[6] * v1[4] * v2[0] * v3[5] * v4[3] * v5[2]) + (v0[6] * v1[4] * v2[2] * v3[0] * v4[3] * v5[5]) + (-1 * v0[6] * v1[4] * v2[2] * v3[0] * v4[5] * v5[3]) + (-1 * v0[6] * v1[4] * v2[2] * v3[3] * v4[0] * v5[5]) + (v0[6] * v1[4] * v2[2] * v3[3] * v4[5] * v5[0]) + (v0[6] * v1[4] * v2[2] * v3[5] * v4[0] * v5[3]) + (-1 * v0[6] * v1[4] * v2[2] * v3[5] * v4[3] * v5[0]) + (-1 * v0[6] * v1[4] * v2[3] * v3[0] * v4[2] * v5[5]) + (v0[6] * v1[4] * v2[3] * v3[0] * v4[5] * v5[2]) + (v0[6] * v1[4] * v2[3] * v3[2] * v4[0] * v5[5]) + (-1 * v0[6] * v1[4] * v2[3] * v3[2] * v4[5] * v5[0]) + (-1 * v0[6] * v1[4] * v2[3] * v3[5] * v4[0] * v5[2]) + (v0[6] * v1[4] * v2[3] * v3[5] * v4[2] * v5[0]) + (v0[6] * v1[4] * v2[5] * v3[0] * v4[2] * v5[3]) + (-1 * v0[6] * v1[4] * v2[5] * v3[0] * v4[3] * v5[2]) + (-1 * v0[6] * v1[4] * v2[5] * v3[2] * v4[0] * v5[3]) + (v0[6] * v1[4] * v2[5] * v3[2] * v4[3] * v5[0]) + (v0[6] * v1[4] * v2[5] * v3[3] * v4[0] * v5[2]) + (-1 * v0[6] * v1[4] * v2[5] * v3[3] * v4[2] * v5[0]) + (v0[6] * v1[5] * v2[0] * v3[2] * v4[3] * v5[4]) + (-1 * v0[6] * v1[5] * v2[0] * v3[2] * v4[4] * v5[3]) + (-1 * v0[6] * v1[5] * v2[0] * v3[3] * v4[2] * v5[4]) + (v0[6] * v1[5] * v2[0] * v3[3] * v4[4] * v5[2]) + (v0[6] * v1[5] * v2[0] * v3[4] * v4[2] * v5[3]) + (-1 * v0[6] * v1[5] * v2[0] * v3[4] * v4[3] * v5[2]) + (-1 * v0[6] * v1[5] * v2[2] * v3[0] * v4[3] * v5[4]) + (v0[6] * v1[5] * v2[2] * v3[0] * v4[4] * v5[3]) + (v0[6] * v1[5] * v2[2] * v3[3] * v4[0] * v5[4]) + (-1 * v0[6] * v1[5] * v2[2] * v3[3] * v4[4] * v5[0]) + (-1 * v0[6] * v1[5] * v2[2] * v3[4] * v4[0] * v5[3]) + (v0[6] * v1[5] * v2[2] * v3[4] * v4[3] * v5[0]) + (v0[6] * v1[5] * v2[3] * v3[0] * v4[2] * v5[4]) + (-1 * v0[6] * v1[5] * v2[3] * v3[0] * v4[4] * v5[2]) + (-1 * v0[6] * v1[5] * v2[3] * v3[2] * v4[0] * v5[4]) + (v0[6] * v1[5] * v2[3] * v3[2] * v4[4] * v5[0]) + (v0[6] * v1[5] * v2[3] * v3[4] * v4[0] * v5[2]) + (-1 * v0[6] * v1[5] * v2[3] * v3[4] * v4[2] * v5[0]) + (-1 * v0[6] * v1[5] * v2[4] * v3[0] * v4[2] * v5[3]) + (v0[6] * v1[5] * v2[4] * v3[0] * v4[3] * v5[2]) + (v0[6] * v1[5] * v2[4] * v3[2] * v4[0] * v5[3]) + (-1 * v0[6] * v1[5] * v2[4] * v3[2] * v4[3] * v5[0]) + (-1 * v0[6] * v1[5] * v2[4] * v3[3] * v4[0] * v5[2]) + (v0[6] * v1[5] * v2[4] * v3[3] * v4[2] * v5[0]);
r0[2] = (v0[0] * v1[1] * v2[3] * v3[4] * v4[5] * v5[6]) + (-1 * v0[0] * v1[1] * v2[3] * v3[4] * v4[6] * v5[5]) + (-1 * v0[0] * v1[1] * v2[3] * v3[5] * v4[4] * v5[6]) + (v0[0] * v1[1] * v2[3] * v3[5] * v4[6] * v5[4]) + (v0[0] * v1[1] * v2[3] * v3[6] * v4[4] * v5[5]) + (-1 * v0[0] * v1[1] * v2[3] * v3[6] * v4[5] * v5[4]) + (-1 * v0[0] * v1[1] * v2[4] * v3[3] * v4[5] * v5[6]) + (v0[0] * v1[1] * v2[4] * v3[3] * v4[6] * v5[5]) + (v0[0] * v1[1] * v2[4] * v3[5] * v4[3] * v5[6]) + (-1 * v0[0] * v1[1] * v2[4] * v3[5] * v4[6] * v5[3]) + (-1 * v0[0] * v1[1] * v2[4] * v3[6] * v4[3] * v5[5]) + (v0[0] * v1[1] * v2[4] * v3[6] * v4[5] * v5[3]) + (v0[0] * v1[1] * v2[5] * v3[3] * v4[4] * v5[6]) + (-1 * v0[0] * v1[1] * v2[5] * v3[3] * v4[6] * v5[4]) + (-1 * v0[0] * v1[1] * v2[5] * v3[4] * v4[3] * v5[6]) + (v0[0] * v1[1] * v2[5] * v3[4] * v4[6] * v5[3]) + (v0[0] * v1[1] * v2[5] * v3[6] * v4[3] * v5[4]) + (-1 * v0[0] * v1[1] * v2[5] * v3[6] * v4[4] * v5[3]) + (-1 * v0[0] * v1[1] * v2[6] * v3[3] * v4[4] * v5[5]) + (v0[0] * v1[1] * v2[6] * v3[3] * v4[5] * v5[4]) + (v0[0] * v1[1] * v2[6] * v3[4] * v4[3] * v5[5]) + (-1 * v0[0] * v1[1] * v2[6] * v3[4] * v4[5] * v5[3]) + (-1 * v0[0] * v1[1] * v2[6] * v3[5] * v4[3] * v5[4]) + (v0[0] * v1[1] * v2[6] * v3[5] * v4[4] * v5[3]) + (-1 * v0[0] * v1[3] * v2[1] * v3[4] * v4[5] * v5[6]) + (v0[0] * v1[3] * v2[1] * v3[4] * v4[6] * v5[5]) + (v0[0] * v1[3] * v2[1] * v3[5] * v4[4] * v5[6]) + (-1 * v0[0] * v1[3] * v2[1] * v3[5] * v4[6] * v5[4]) + (-1 * v0[0] * v1[3] * v2[1] * v3[6] * v4[4] * v5[5]) + (v0[0] * v1[3] * v2[1] * v3[6] * v4[5] * v5[4]) + (v0[0] * v1[3] * v2[4] * v3[1] * v4[5] * v5[6]) + (-1 * v0[0] * v1[3] * v2[4] * v3[1] * v4[6] * v5[5]) + (-1 * v0[0] * v1[3] * v2[4] * v3[5] * v4[1] * v5[6]) + (v0[0] * v1[3] * v2[4] * v3[5] * v4[6] * v5[1]) + (v0[0] * v1[3] * v2[4] * v3[6] * v4[1] * v5[5]) + (-1 * v0[0] * v1[3] * v2[4] * v3[6] * v4[5] * v5[1]) + (-1 * v0[0] * v1[3] * v2[5] * v3[1] * v4[4] * v5[6]) + (v0[0] * v1[3] * v2[5] * v3[1] * v4[6] * v5[4]) + (v0[0] * v1[3] * v2[5] * v3[4] * v4[1] * v5[6]) + (-1 * v0[0] * v1[3] * v2[5] * v3[4] * v4[6] * v5[1]) + (-1 * v0[0] * v1[3] * v2[5] * v3[6] * v4[1] * v5[4]) + (v0[0] * v1[3] * v2[5] * v3[6] * v4[4] * v5[1]) + (v0[0] * v1[3] * v2[6] * v3[1] * v4[4] * v5[5]) + (-1 * v0[0] * v1[3] * v2[6] * v3[1] * v4[5] * v5[4]) + (-1 * v0[0] * v1[3] * v2[6] * v3[4] * v4[1] * v5[5]) + (v0[0] * v1[3] * v2[6] * v3[4] * v4[5] * v5[1]) + (v0[0] * v1[3] * v2[6] * v3[5] * v4[1] * v5[4]) + (-1 * v0[0] * v1[3] * v2[6] * v3[5] * v4[4] * v5[1]) + (v0[0] * v1[4] * v2[1] * v3[3] * v4[5] * v5[6]) + (-1 * v0[0] * v1[4] * v2[1] * v3[3] * v4[6] * v5[5]) + (-1 * v0[0] * v1[4] * v2[1] * v3[5] * v4[3] * v5[6]) + (v0[0] * v1[4] * v2[1] * v3[5] * v4[6] * v5[3]) + (v0[0] * v1[4] * v2[1] * v3[6] * v4[3] * v5[5]) + (-1 * v0[0] * v1[4] * v2[1] * v3[6] * v4[5] * v5[3]) + (-1 * v0[0] * v1[4] * v2[3] * v3[1] * v4[5] * v5[6]) + (v0[0] * v1[4] * v2[3] * v3[1] * v4[6] * v5[5]) + (v0[0] * v1[4] * v2[3] * v3[5] * v4[1] * v5[6]) + (-1 * v0[0] * v1[4] * v2[3] * v3[5] * v4[6] * v5[1]) + (-1 * v0[0] * v1[4] * v2[3] * v3[6] * v4[1] * v5[5]) + (v0[0] * v1[4] * v2[3] * v3[6] * v4[5] * v5[1]) + (v0[0] * v1[4] * v2[5] * v3[1] * v4[3] * v5[6]) + (-1 * v0[0] * v1[4] * v2[5] * v3[1] * v4[6] * v5[3]) + (-1 * v0[0] * v1[4] * v2[5] * v3[3] * v4[1] * v5[6]) + (v0[0] * v1[4] * v2[5] * v3[3] * v4[6] * v5[1]) + (v0[0] * v1[4] * v2[5] * v3[6] * v4[1] * v5[3]) + (-1 * v0[0] * v1[4] * v2[5] * v3[6] * v4[3] * v5[1]) + (-1 * v0[0] * v1[4] * v2[6] * v3[1] * v4[3] * v5[5]) + (v0[0] * v1[4] * v2[6] * v3[1] * v4[5] * v5[3]) + (v0[0] * v1[4] * v2[6] * v3[3] * v4[1] * v5[5]) + (-1 * v0[0] * v1[4] * v2[6] * v3[3] * v4[5] * v5[1]) + (-1 * v0[0] * v1[4] * v2[6] * v3[5] * v4[1] * v5[3]) + (v0[0] * v1[4] * v2[6] * v3[5] * v4[3] * v5[1]) + (-1 * v0[0] * v1[5] * v2[1] * v3[3] * v4[4] * v5[6]) + (v0[0] * v1[5] * v2[1] * v3[3] * v4[6] * v5[4]) + (v0[0] * v1[5] * v2[1] * v3[4] * v4[3] * v5[6]) + (-1 * v0[0] * v1[5] * v2[1] * v3[4] * v4[6] * v5[3]) + (-1 * v0[0] * v1[5] * v2[1] * v3[6] * v4[3] * v5[4]) + (v0[0] * v1[5] * v2[1] * v3[6] * v4[4] * v5[3]) + (v0[0] * v1[5] * v2[3] * v3[1] * v4[4] * v5[6]) + (-1 * v0[0] * v1[5] * v2[3] * v3[1] * v4[6] * v5[4]) + (-1 * v0[0] * v1[5] * v2[3] * v3[4] * v4[1] * v5[6]) + (v0[0] * v1[5] * v2[3] * v3[4] * v4[6] * v5[1]) + (v0[0] * v1[5] * v2[3] * v3[6] * v4[1] * v5[4]) + (-1 * v0[0] * v1[5] * v2[3] * v3[6] * v4[4] * v5[1]) + (-1 * v0[0] * v1[5] * v2[4] * v3[1] * v4[3] * v5[6]) + (v0[0] * v1[5] * v2[4] * v3[1] * v4[6] * v5[3]) + (v0[0] * v1[5] * v2[4] * v3[3] * v4[1] * v5[6]) + (-1 * v0[0] * v1[5] * v2[4] * v3[3] * v4[6] * v5[1]) + (-1 * v0[0] * v1[5] * v2[4] * v3[6] * v4[1] * v5[3]) + (v0[0] * v1[5] * v2[4] * v3[6] * v4[3] * v5[1]) + (v0[0] * v1[5] * v2[6] * v3[1] * v4[3] * v5[4]) + (-1 * v0[0] * v1[5] * v2[6] * v3[1] * v4[4] * v5[3]) + (-1 * v0[0] * v1[5] * v2[6] * v3[3] * v4[1] * v5[4]) + (v0[0] * v1[5] * v2[6] * v3[3] * v4[4] * v5[1]) + (v0[0] * v1[5] * v2[6] * v3[4] * v4[1] * v5[3]) + (-1 * v0[0] * v1[5] * v2[6] * v3[4] * v4[3] * v5[1]) + (v0[0] * v1[6] * v2[1] * v3[3] * v4[4] * v5[5]) + (-1 * v0[0] * v1[6] * v2[1] * v3[3] * v4[5] * v5[4]) + (-1 * v0[0] * v1[6] * v2[1] * v3[4] * v4[3] * v5[5]) + (v0[0] * v1[6] * v2[1] * v3[4] * v4[5] * v5[3]) + (v0[0] * v1[6] * v2[1] * v3[5] * v4[3] * v5[4]) + (-1 * v0[0] * v1[6] * v2[1] * v3[5] * v4[4] * v5[3]) + (-1 * v0[0] * v1[6] * v2[3] * v3[1] * v4[4] * v5[5]) + (v0[0] * v1[6] * v2[3] * v3[1] * v4[5] * v5[4]) + (v0[0] * v1[6] * v2[3] * v3[4] * v4[1] * v5[5]) + (-1 * v0[0] * v1[6] * v2[3] * v3[4] * v4[5] * v5[1]) + (-1 * v0[0] * v1[6] * v2[3] * v3[5] * v4[1] * v5[4]) + (v0[0] * v1[6] * v2[3] * v3[5] * v4[4] * v5[1]) + (v0[0] * v1[6] * v2[4] * v3[1] * v4[3] * v5[5]) + (-1 * v0[0] * v1[6] * v2[4] * v3[1] * v4[5] * v5[3]) + (-1 * v0[0] * v1[6] * v2[4] * v3[3] * v4[1] * v5[5]) + (v0[0] * v1[6] * v2[4] * v3[3] * v4[5] * v5[1]) + (v0[0] * v1[6] * v2[4] * v3[5] * v4[1] * v5[3]) + (-1 * v0[0] * v1[6] * v2[4] * v3[5] * v4[3] * v5[1]) + (-1 * v0[0] * v1[6] * v2[5] * v3[1] * v4[3] * v5[4]) + (v0[0] * v1[6] * v2[5] * v3[1] * v4[4] * v5[3]) + (v0[0] * v1[6] * v2[5] * v3[3] * v4[1] * v5[4]) + (-1 * v0[0] * v1[6] * v2[5] * v3[3] * v4[4] * v5[1]) + (-1 * v0[0] * v1[6] * v2[5] * v3[4] * v4[1] * v5[3]) + (v0[0] * v1[6] * v2[5] * v3[4] * v4[3] * v5[1]) + (-1 * v0[1] * v1[0] * v2[3] * v3[4] * v4[5] * v5[6]) + (v0[1] * v1[0] * v2[3] * v3[4] * v4[6] * v5[5]) + (v0[1] * v1[0] * v2[3] * v3[5] * v4[4] * v5[6]) + (-1 * v0[1] * v1[0] * v2[3] * v3[5] * v4[6] * v5[4]) + (-1 * v0[1] * v1[0] * v2[3] * v3[6] * v4[4] * v5[5]) + (v0[1] * v1[0] * v2[3] * v3[6] * v4[5] * v5[4]) + (v0[1] * v1[0] * v2[4] * v3[3] * v4[5] * v5[6]) + (-1 * v0[1] * v1[0] * v2[4] * v3[3] * v4[6] * v5[5]) + (-1 * v0[1] * v1[0] * v2[4] * v3[5] * v4[3] * v5[6]) + (v0[1] * v1[0] * v2[4] * v3[5] * v4[6] * v5[3]) + (v0[1] * v1[0] * v2[4] * v3[6] * v4[3] * v5[5]) + (-1 * v0[1] * v1[0] * v2[4] * v3[6] * v4[5] * v5[3]) + (-1 * v0[1] * v1[0] * v2[5] * v3[3] * v4[4] * v5[6]) + (v0[1] * v1[0] * v2[5] * v3[3] * v4[6] * v5[4]) + (v0[1] * v1[0] * v2[5] * v3[4] * v4[3] * v5[6]) + (-1 * v0[1] * v1[0] * v2[5] * v3[4] * v4[6] * v5[3]) + (-1 * v0[1] * v1[0] * v2[5] * v3[6] * v4[3] * v5[4]) + (v0[1] * v1[0] * v2[5] * v3[6] * v4[4] * v5[3]) + (v0[1] * v1[0] * v2[6] * v3[3] * v4[4] * v5[5]) + (-1 * v0[1] * v1[0] * v2[6] * v3[3] * v4[5] * v5[4]) + (-1 * v0[1] * v1[0] * v2[6] * v3[4] * v4[3] * v5[5]) + (v0[1] * v1[0] * v2[6] * v3[4] * v4[5] * v5[3]) + (v0[1] * v1[0] * v2[6] * v3[5] * v4[3] * v5[4]) + (-1 * v0[1] * v1[0] * v2[6] * v3[5] * v4[4] * v5[3]) + (v0[1] * v1[3] * v2[0] * v3[4] * v4[5] * v5[6]) + (-1 * v0[1] * v1[3] * v2[0] * v3[4] * v4[6] * v5[5]) + (-1 * v0[1] * v1[3] * v2[0] * v3[5] * v4[4] * v5[6]) + (v0[1] * v1[3] * v2[0] * v3[5] * v4[6] * v5[4]) + (v0[1] * v1[3] * v2[0] * v3[6] * v4[4] * v5[5]) + (-1 * v0[1] * v1[3] * v2[0] * v3[6] * v4[5] * v5[4]) + (-1 * v0[1] * v1[3] * v2[4] * v3[0] * v4[5] * v5[6]) + (v0[1] * v1[3] * v2[4] * v3[0] * v4[6] * v5[5]) + (v0[1] * v1[3] * v2[4] * v3[5] * v4[0] * v5[6]) + (-1 * v0[1] * v1[3] * v2[4] * v3[5] * v4[6] * v5[0]) + (-1 * v0[1] * v1[3] * v2[4] * v3[6] * v4[0] * v5[5]) + (v0[1] * v1[3] * v2[4] * v3[6] * v4[5] * v5[0]) + (v0[1] * v1[3] * v2[5] * v3[0] * v4[4] * v5[6]) + (-1 * v0[1] * v1[3] * v2[5] * v3[0] * v4[6] * v5[4]) + (-1 * v0[1] * v1[3] * v2[5] * v3[4] * v4[0] * v5[6]) + (v0[1] * v1[3] * v2[5] * v3[4] * v4[6] * v5[0]) + (v0[1] * v1[3] * v2[5] * v3[6] * v4[0] * v5[4]) + (-1 * v0[1] * v1[3] * v2[5] * v3[6] * v4[4] * v5[0]) + (-1 * v0[1] * v1[3] * v2[6] * v3[0] * v4[4] * v5[5]) + (v0[1] * v1[3] * v2[6] * v3[0] * v4[5] * v5[4]) + (v0[1] * v1[3] * v2[6] * v3[4] * v4[0] * v5[5]) + (-1 * v0[1] * v1[3] * v2[6] * v3[4] * v4[5] * v5[0]) + (-1 * v0[1] * v1[3] * v2[6] * v3[5] * v4[0] * v5[4]) + (v0[1] * v1[3] * v2[6] * v3[5] * v4[4] * v5[0]) + (-1 * v0[1] * v1[4] * v2[0] * v3[3] * v4[5] * v5[6]) + (v0[1] * v1[4] * v2[0] * v3[3] * v4[6] * v5[5]) + (v0[1] * v1[4] * v2[0] * v3[5] * v4[3] * v5[6]) + (-1 * v0[1] * v1[4] * v2[0] * v3[5] * v4[6] * v5[3]) + (-1 * v0[1] * v1[4] * v2[0] * v3[6] * v4[3] * v5[5]) + (v0[1] * v1[4] * v2[0] * v3[6] * v4[5] * v5[3]) + (v0[1] * v1[4] * v2[3] * v3[0] * v4[5] * v5[6]) + (-1 * v0[1] * v1[4] * v2[3] * v3[0] * v4[6] * v5[5]) + (-1 * v0[1] * v1[4] * v2[3] * v3[5] * v4[0] * v5[6]) + (v0[1] * v1[4] * v2[3] * v3[5] * v4[6] * v5[0]) + (v0[1] * v1[4] * v2[3] * v3[6] * v4[0] * v5[5]) + (-1 * v0[1] * v1[4] * v2[3] * v3[6] * v4[5] * v5[0]) + (-1 * v0[1] * v1[4] * v2[5] * v3[0] * v4[3] * v5[6]) + (v0[1] * v1[4] * v2[5] * v3[0] * v4[6] * v5[3]) + (v0[1] * v1[4] * v2[5] * v3[3] * v4[0] * v5[6]) + (-1 * v0[1] * v1[4] * v2[5] * v3[3] * v4[6] * v5[0]) + (-1 * v0[1] * v1[4] * v2[5] * v3[6] * v4[0] * v5[3]) + (v0[1] * v1[4] * v2[5] * v3[6] * v4[3] * v5[0]) + (v0[1] * v1[4] * v2[6] * v3[0] * v4[3] * v5[5]) + (-1 * v0[1] * v1[4] * v2[6] * v3[0] * v4[5] * v5[3]) + (-1 * v0[1] * v1[4] * v2[6] * v3[3] * v4[0] * v5[5]) + (v0[1] * v1[4] * v2[6] * v3[3] * v4[5] * v5[0]) + (v0[1] * v1[4] * v2[6] * v3[5] * v4[0] * v5[3]) + (-1 * v0[1] * v1[4] * v2[6] * v3[5] * v4[3] * v5[0]) + (v0[1] * v1[5] * v2[0] * v3[3] * v4[4] * v5[6]) + (-1 * v0[1] * v1[5] * v2[0] * v3[3] * v4[6] * v5[4]) + (-1 * v0[1] * v1[5] * v2[0] * v3[4] * v4[3] * v5[6]) + (v0[1] * v1[5] * v2[0] * v3[4] * v4[6] * v5[3]) + (v0[1] * v1[5] * v2[0] * v3[6] * v4[3] * v5[4]) + (-1 * v0[1] * v1[5] * v2[0] * v3[6] * v4[4] * v5[3]) + (-1 * v0[1] * v1[5] * v2[3] * v3[0] * v4[4] * v5[6]) + (v0[1] * v1[5] * v2[3] * v3[0] * v4[6] * v5[4]) + (v0[1] * v1[5] * v2[3] * v3[4] * v4[0] * v5[6]) + (-1 * v0[1] * v1[5] * v2[3] * v3[4] * v4[6] * v5[0]) + (-1 * v0[1] * v1[5] * v2[3] * v3[6] * v4[0] * v5[4]) + (v0[1] * v1[5] * v2[3] * v3[6] * v4[4] * v5[0]) + (v0[1] * v1[5] * v2[4] * v3[0] * v4[3] * v5[6]) + (-1 * v0[1] * v1[5] * v2[4] * v3[0] * v4[6] * v5[3]) + (-1 * v0[1] * v1[5] * v2[4] * v3[3] * v4[0] * v5[6]) + (v0[1] * v1[5] * v2[4] * v3[3] * v4[6] * v5[0]) + (v0[1] * v1[5] * v2[4] * v3[6] * v4[0] * v5[3]) + (-1 * v0[1] * v1[5] * v2[4] * v3[6] * v4[3] * v5[0]) + (-1 * v0[1] * v1[5] * v2[6] * v3[0] * v4[3] * v5[4]) + (v0[1] * v1[5] * v2[6] * v3[0] * v4[4] * v5[3]) + (v0[1] * v1[5] * v2[6] * v3[3] * v4[0] * v5[4]) + (-1 * v0[1] * v1[5] * v2[6] * v3[3] * v4[4] * v5[0]) + (-1 * v0[1] * v1[5] * v2[6] * v3[4] * v4[0] * v5[3]) + (v0[1] * v1[5] * v2[6] * v3[4] * v4[3] * v5[0]) + (-1 * v0[1] * v1[6] * v2[0] * v3[3] * v4[4] * v5[5]) + (v0[1] * v1[6] * v2[0] * v3[3] * v4[5] * v5[4]) + (v0[1] * v1[6] * v2[0] * v3[4] * v4[3] * v5[5]) + (-1 * v0[1] * v1[6] * v2[0] * v3[4] * v4[5] * v5[3]) + (-1 * v0[1] * v1[6] * v2[0] * v3[5] * v4[3] * v5[4]) + (v0[1] * v1[6] * v2[0] * v3[5] * v4[4] * v5[3]) + (v0[1] * v1[6] * v2[3] * v3[0] * v4[4] * v5[5]) + (-1 * v0[1] * v1[6] * v2[3] * v3[0] * v4[5] * v5[4]) + (-1 * v0[1] * v1[6] * v2[3] * v3[4] * v4[0] * v5[5]) + (v0[1] * v1[6] * v2[3] * v3[4] * v4[5] * v5[0]) + (v0[1] * v1[6] * v2[3] * v3[5] * v4[0] * v5[4]) + (-1 * v0[1] * v1[6] * v2[3] * v3[5] * v4[4] * v5[0]) + (-1 * v0[1] * v1[6] * v2[4] * v3[0] * v4[3] * v5[5]) + (v0[1] * v1[6] * v2[4] * v3[0] * v4[5] * v5[3]) + (v0[1] * v1[6] * v2[4] * v3[3] * v4[0] * v5[5]) + (-1 * v0[1] * v1[6] * v2[4] * v3[3] * v4[5] * v5[0]) + (-1 * v0[1] * v1[6] * v2[4] * v3[5] * v4[0] * v5[3]) + (v0[1] * v1[6] * v2[4] * v3[5] * v4[3] * v5[0]) + (v0[1] * v1[6] * v2[5] * v3[0] * v4[3] * v5[4]) + (-1 * v0[1] * v1[6] * v2[5] * v3[0] * v4[4] * v5[3]) + (-1 * v0[1] * v1[6] * v2[5] * v3[3] * v4[0] * v5[4]) + (v0[1] * v1[6] * v2[5] * v3[3] * v4[4] * v5[0]) + (v0[1] * v1[6] * v2[5] * v3[4] * v4[0] * v5[3]) + (-1 * v0[1] * v1[6] * v2[5] * v3[4] * v4[3] * v5[0]) + (v0[3] * v1[0] * v2[1] * v3[4] * v4[5] * v5[6]) + (-1 * v0[3] * v1[0] * v2[1] * v3[4] * v4[6] * v5[5]) + (-1 * v0[3] * v1[0] * v2[1] * v3[5] * v4[4] * v5[6]) + (v0[3] * v1[0] * v2[1] * v3[5] * v4[6] * v5[4]) + (v0[3] * v1[0] * v2[1] * v3[6] * v4[4] * v5[5]) + (-1 * v0[3] * v1[0] * v2[1] * v3[6] * v4[5] * v5[4]) + (-1 * v0[3] * v1[0] * v2[4] * v3[1] * v4[5] * v5[6]) + (v0[3] * v1[0] * v2[4] * v3[1] * v4[6] * v5[5]) + (v0[3] * v1[0] * v2[4] * v3[5] * v4[1] * v5[6]) + (-1 * v0[3] * v1[0] * v2[4] * v3[5] * v4[6] * v5[1]) + (-1 * v0[3] * v1[0] * v2[4] * v3[6] * v4[1] * v5[5]) + (v0[3] * v1[0] * v2[4] * v3[6] * v4[5] * v5[1]) + (v0[3] * v1[0] * v2[5] * v3[1] * v4[4] * v5[6]) + (-1 * v0[3] * v1[0] * v2[5] * v3[1] * v4[6] * v5[4]) + (-1 * v0[3] * v1[0] * v2[5] * v3[4] * v4[1] * v5[6]) + (v0[3] * v1[0] * v2[5] * v3[4] * v4[6] * v5[1]) + (v0[3] * v1[0] * v2[5] * v3[6] * v4[1] * v5[4]) + (-1 * v0[3] * v1[0] * v2[5] * v3[6] * v4[4] * v5[1]) + (-1 * v0[3] * v1[0] * v2[6] * v3[1] * v4[4] * v5[5]) + (v0[3] * v1[0] * v2[6] * v3[1] * v4[5] * v5[4]) + (v0[3] * v1[0] * v2[6] * v3[4] * v4[1] * v5[5]) + (-1 * v0[3] * v1[0] * v2[6] * v3[4] * v4[5] * v5[1]) + (-1 * v0[3] * v1[0] * v2[6] * v3[5] * v4[1] * v5[4]) + (v0[3] * v1[0] * v2[6] * v3[5] * v4[4] * v5[1]) + (-1 * v0[3] * v1[1] * v2[0] * v3[4] * v4[5] * v5[6]) + (v0[3] * v1[1] * v2[0] * v3[4] * v4[6] * v5[5]) + (v0[3] * v1[1] * v2[0] * v3[5] * v4[4] * v5[6]) + (-1 * v0[3] * v1[1] * v2[0] * v3[5] * v4[6] * v5[4]) + (-1 * v0[3] * v1[1] * v2[0] * v3[6] * v4[4] * v5[5]) + (v0[3] * v1[1] * v2[0] * v3[6] * v4[5] * v5[4]) + (v0[3] * v1[1] * v2[4] * v3[0] * v4[5] * v5[6]) + (-1 * v0[3] * v1[1] * v2[4] * v3[0] * v4[6] * v5[5]) + (-1 * v0[3] * v1[1] * v2[4] * v3[5] * v4[0] * v5[6]) + (v0[3] * v1[1] * v2[4] * v3[5] * v4[6] * v5[0]) + (v0[3] * v1[1] * v2[4] * v3[6] * v4[0] * v5[5]) + (-1 * v0[3] * v1[1] * v2[4] * v3[6] * v4[5] * v5[0]) + (-1 * v0[3] * v1[1] * v2[5] * v3[0] * v4[4] * v5[6]) + (v0[3] * v1[1] * v2[5] * v3[0] * v4[6] * v5[4]) + (v0[3] * v1[1] * v2[5] * v3[4] * v4[0] * v5[6]) + (-1 * v0[3] * v1[1] * v2[5] * v3[4] * v4[6] * v5[0]) + (-1 * v0[3] * v1[1] * v2[5] * v3[6] * v4[0] * v5[4]) + (v0[3] * v1[1] * v2[5] * v3[6] * v4[4] * v5[0]) + (v0[3] * v1[1] * v2[6] * v3[0] * v4[4] * v5[5]) + (-1 * v0[3] * v1[1] * v2[6] * v3[0] * v4[5] * v5[4]) + (-1 * v0[3] * v1[1] * v2[6] * v3[4] * v4[0] * v5[5]) + (v0[3] * v1[1] * v2[6] * v3[4] * v4[5] * v5[0]) + (v0[3] * v1[1] * v2[6] * v3[5] * v4[0] * v5[4]) + (-1 * v0[3] * v1[1] * v2[6] * v3[5] * v4[4] * v5[0]) + (v0[3] * v1[4] * v2[0] * v3[1] * v4[5] * v5[6]) + (-1 * v0[3] * v1[4] * v2[0] * v3[1] * v4[6] * v5[5]) + (-1 * v0[3] * v1[4] * v2[0] * v3[5] * v4[1] * v5[6]) + (v0[3] * v1[4] * v2[0] * v3[5] * v4[6] * v5[1]) + (v0[3] * v1[4] * v2[0] * v3[6] * v4[1] * v5[5]) + (-1 * v0[3] * v1[4] * v2[0] * v3[6] * v4[5] * v5[1]) + (-1 * v0[3] * v1[4] * v2[1] * v3[0] * v4[5] * v5[6]) + (v0[3] * v1[4] * v2[1] * v3[0] * v4[6] * v5[5]) + (v0[3] * v1[4] * v2[1] * v3[5] * v4[0] * v5[6]) + (-1 * v0[3] * v1[4] * v2[1] * v3[5] * v4[6] * v5[0]) + (-1 * v0[3] * v1[4] * v2[1] * v3[6] * v4[0] * v5[5]) + (v0[3] * v1[4] * v2[1] * v3[6] * v4[5] * v5[0]) + (v0[3] * v1[4] * v2[5] * v3[0] * v4[1] * v5[6]) + (-1 * v0[3] * v1[4] * v2[5] * v3[0] * v4[6] * v5[1]) + (-1 * v0[3] * v1[4] * v2[5] * v3[1] * v4[0] * v5[6]) + (v0[3] * v1[4] * v2[5] * v3[1] * v4[6] * v5[0]) + (v0[3] * v1[4] * v2[5] * v3[6] * v4[0] * v5[1]) + (-1 * v0[3] * v1[4] * v2[5] * v3[6] * v4[1] * v5[0]) + (-1 * v0[3] * v1[4] * v2[6] * v3[0] * v4[1] * v5[5]) + (v0[3] * v1[4] * v2[6] * v3[0] * v4[5] * v5[1]) + (v0[3] * v1[4] * v2[6] * v3[1] * v4[0] * v5[5]) + (-1 * v0[3] * v1[4] * v2[6] * v3[1] * v4[5] * v5[0]) + (-1 * v0[3] * v1[4] * v2[6] * v3[5] * v4[0] * v5[1]) + (v0[3] * v1[4] * v2[6] * v3[5] * v4[1] * v5[0]) + (-1 * v0[3] * v1[5] * v2[0] * v3[1] * v4[4] * v5[6]) + (v0[3] * v1[5] * v2[0] * v3[1] * v4[6] * v5[4]) + (v0[3] * v1[5] * v2[0] * v3[4] * v4[1] * v5[6]) + (-1 * v0[3] * v1[5] * v2[0] * v3[4] * v4[6] * v5[1]) + (-1 * v0[3] * v1[5] * v2[0] * v3[6] * v4[1] * v5[4]) + (v0[3] * v1[5] * v2[0] * v3[6] * v4[4] * v5[1]) + (v0[3] * v1[5] * v2[1] * v3[0] * v4[4] * v5[6]) + (-1 * v0[3] * v1[5] * v2[1] * v3[0] * v4[6] * v5[4]) + (-1 * v0[3] * v1[5] * v2[1] * v3[4] * v4[0] * v5[6]) + (v0[3] * v1[5] * v2[1] * v3[4] * v4[6] * v5[0]) + (v0[3] * v1[5] * v2[1] * v3[6] * v4[0] * v5[4]) + (-1 * v0[3] * v1[5] * v2[1] * v3[6] * v4[4] * v5[0]) + (-1 * v0[3] * v1[5] * v2[4] * v3[0] * v4[1] * v5[6]) + (v0[3] * v1[5] * v2[4] * v3[0] * v4[6] * v5[1]) + (v0[3] * v1[5] * v2[4] * v3[1] * v4[0] * v5[6]) + (-1 * v0[3] * v1[5] * v2[4] * v3[1] * v4[6] * v5[0]) + (-1 * v0[3] * v1[5] * v2[4] * v3[6] * v4[0] * v5[1]) + (v0[3] * v1[5] * v2[4] * v3[6] * v4[1] * v5[0]) + (v0[3] * v1[5] * v2[6] * v3[0] * v4[1] * v5[4]) + (-1 * v0[3] * v1[5] * v2[6] * v3[0] * v4[4] * v5[1]) + (-1 * v0[3] * v1[5] * v2[6] * v3[1] * v4[0] * v5[4]) + (v0[3] * v1[5] * v2[6] * v3[1] * v4[4] * v5[0]) + (v0[3] * v1[5] * v2[6] * v3[4] * v4[0] * v5[1]) + (-1 * v0[3] * v1[5] * v2[6] * v3[4] * v4[1] * v5[0]) + (v0[3] * v1[6] * v2[0] * v3[1] * v4[4] * v5[5]) + (-1 * v0[3] * v1[6] * v2[0] * v3[1] * v4[5] * v5[4]) + (-1 * v0[3] * v1[6] * v2[0] * v3[4] * v4[1] * v5[5]) + (v0[3] * v1[6] * v2[0] * v3[4] * v4[5] * v5[1]) + (v0[3] * v1[6] * v2[0] * v3[5] * v4[1] * v5[4]) + (-1 * v0[3] * v1[6] * v2[0] * v3[5] * v4[4] * v5[1]) + (-1 * v0[3] * v1[6] * v2[1] * v3[0] * v4[4] * v5[5]) + (v0[3] * v1[6] * v2[1] * v3[0] * v4[5] * v5[4]) + (v0[3] * v1[6] * v2[1] * v3[4] * v4[0] * v5[5]) + (-1 * v0[3] * v1[6] * v2[1] * v3[4] * v4[5] * v5[0]) + (-1 * v0[3] * v1[6] * v2[1] * v3[5] * v4[0] * v5[4]) + (v0[3] * v1[6] * v2[1] * v3[5] * v4[4] * v5[0]) + (v0[3] * v1[6] * v2[4] * v3[0] * v4[1] * v5[5]) + (-1 * v0[3] * v1[6] * v2[4] * v3[0] * v4[5] * v5[1]) + (-1 * v0[3] * v1[6] * v2[4] * v3[1] * v4[0] * v5[5]) + (v0[3] * v1[6] * v2[4] * v3[1] * v4[5] * v5[0]) + (v0[3] * v1[6] * v2[4] * v3[5] * v4[0] * v5[1]) + (-1 * v0[3] * v1[6] * v2[4] * v3[5] * v4[1] * v5[0]) + (-1 * v0[3] * v1[6] * v2[5] * v3[0] * v4[1] * v5[4]) + (v0[3] * v1[6] * v2[5] * v3[0] * v4[4] * v5[1]) + (v0[3] * v1[6] * v2[5] * v3[1] * v4[0] * v5[4]) + (-1 * v0[3] * v1[6] * v2[5] * v3[1] * v4[4] * v5[0]) + (-1 * v0[3] * v1[6] * v2[5] * v3[4] * v4[0] * v5[1]) + (v0[3] * v1[6] * v2[5] * v3[4] * v4[1] * v5[0]) + (-1 * v0[4] * v1[0] * v2[1] * v3[3] * v4[5] * v5[6]) + (v0[4] * v1[0] * v2[1] * v3[3] * v4[6] * v5[5]) + (v0[4] * v1[0] * v2[1] * v3[5] * v4[3] * v5[6]) + (-1 * v0[4] * v1[0] * v2[1] * v3[5] * v4[6] * v5[3]) + (-1 * v0[4] * v1[0] * v2[1] * v3[6] * v4[3] * v5[5]) + (v0[4] * v1[0] * v2[1] * v3[6] * v4[5] * v5[3]) + (v0[4] * v1[0] * v2[3] * v3[1] * v4[5] * v5[6]) + (-1 * v0[4] * v1[0] * v2[3] * v3[1] * v4[6] * v5[5]) + (-1 * v0[4] * v1[0] * v2[3] * v3[5] * v4[1] * v5[6]) + (v0[4] * v1[0] * v2[3] * v3[5] * v4[6] * v5[1]) + (v0[4] * v1[0] * v2[3] * v3[6] * v4[1] * v5[5]) + (-1 * v0[4] * v1[0] * v2[3] * v3[6] * v4[5] * v5[1]) + (-1 * v0[4] * v1[0] * v2[5] * v3[1] * v4[3] * v5[6]) + (v0[4] * v1[0] * v2[5] * v3[1] * v4[6] * v5[3]) + (v0[4] * v1[0] * v2[5] * v3[3] * v4[1] * v5[6]) + (-1 * v0[4] * v1[0] * v2[5] * v3[3] * v4[6] * v5[1]) + (-1 * v0[4] * v1[0] * v2[5] * v3[6] * v4[1] * v5[3]) + (v0[4] * v1[0] * v2[5] * v3[6] * v4[3] * v5[1]) + (v0[4] * v1[0] * v2[6] * v3[1] * v4[3] * v5[5]) + (-1 * v0[4] * v1[0] * v2[6] * v3[1] * v4[5] * v5[3]) + (-1 * v0[4] * v1[0] * v2[6] * v3[3] * v4[1] * v5[5]) + (v0[4] * v1[0] * v2[6] * v3[3] * v4[5] * v5[1]) + (v0[4] * v1[0] * v2[6] * v3[5] * v4[1] * v5[3]) + (-1 * v0[4] * v1[0] * v2[6] * v3[5] * v4[3] * v5[1]) + (v0[4] * v1[1] * v2[0] * v3[3] * v4[5] * v5[6]) + (-1 * v0[4] * v1[1] * v2[0] * v3[3] * v4[6] * v5[5]) + (-1 * v0[4] * v1[1] * v2[0] * v3[5] * v4[3] * v5[6]) + (v0[4] * v1[1] * v2[0] * v3[5] * v4[6] * v5[3]) + (v0[4] * v1[1] * v2[0] * v3[6] * v4[3] * v5[5]) + (-1 * v0[4] * v1[1] * v2[0] * v3[6] * v4[5] * v5[3]) + (-1 * v0[4] * v1[1] * v2[3] * v3[0] * v4[5] * v5[6]) + (v0[4] * v1[1] * v2[3] * v3[0] * v4[6] * v5[5]) + (v0[4] * v1[1] * v2[3] * v3[5] * v4[0] * v5[6]) + (-1 * v0[4] * v1[1] * v2[3] * v3[5] * v4[6] * v5[0]) + (-1 * v0[4] * v1[1] * v2[3] * v3[6] * v4[0] * v5[5]) + (v0[4] * v1[1] * v2[3] * v3[6] * v4[5] * v5[0]) + (v0[4] * v1[1] * v2[5] * v3[0] * v4[3] * v5[6]) + (-1 * v0[4] * v1[1] * v2[5] * v3[0] * v4[6] * v5[3]) + (-1 * v0[4] * v1[1] * v2[5] * v3[3] * v4[0] * v5[6]) + (v0[4] * v1[1] * v2[5] * v3[3] * v4[6] * v5[0]) + (v0[4] * v1[1] * v2[5] * v3[6] * v4[0] * v5[3]) + (-1 * v0[4] * v1[1] * v2[5] * v3[6] * v4[3] * v5[0]) + (-1 * v0[4] * v1[1] * v2[6] * v3[0] * v4[3] * v5[5]) + (v0[4] * v1[1] * v2[6] * v3[0] * v4[5] * v5[3]) + (v0[4] * v1[1] * v2[6] * v3[3] * v4[0] * v5[5]) + (-1 * v0[4] * v1[1] * v2[6] * v3[3] * v4[5] * v5[0]) + (-1 * v0[4] * v1[1] * v2[6] * v3[5] * v4[0] * v5[3]) + (v0[4] * v1[1] * v2[6] * v3[5] * v4[3] * v5[0]) + (-1 * v0[4] * v1[3] * v2[0] * v3[1] * v4[5] * v5[6]) + (v0[4] * v1[3] * v2[0] * v3[1] * v4[6] * v5[5]) + (v0[4] * v1[3] * v2[0] * v3[5] * v4[1] * v5[6]) + (-1 * v0[4] * v1[3] * v2[0] * v3[5] * v4[6] * v5[1]) + (-1 * v0[4] * v1[3] * v2[0] * v3[6] * v4[1] * v5[5]) + (v0[4] * v1[3] * v2[0] * v3[6] * v4[5] * v5[1]) + (v0[4] * v1[3] * v2[1] * v3[0] * v4[5] * v5[6]) + (-1 * v0[4] * v1[3] * v2[1] * v3[0] * v4[6] * v5[5]) + (-1 * v0[4] * v1[3] * v2[1] * v3[5] * v4[0] * v5[6]) + (v0[4] * v1[3] * v2[1] * v3[5] * v4[6] * v5[0]) + (v0[4] * v1[3] * v2[1] * v3[6] * v4[0] * v5[5]) + (-1 * v0[4] * v1[3] * v2[1] * v3[6] * v4[5] * v5[0]) + (-1 * v0[4] * v1[3] * v2[5] * v3[0] * v4[1] * v5[6]) + (v0[4] * v1[3] * v2[5] * v3[0] * v4[6] * v5[1]) + (v0[4] * v1[3] * v2[5] * v3[1] * v4[0] * v5[6]) + (-1 * v0[4] * v1[3] * v2[5] * v3[1] * v4[6] * v5[0]) + (-1 * v0[4] * v1[3] * v2[5] * v3[6] * v4[0] * v5[1]) + (v0[4] * v1[3] * v2[5] * v3[6] * v4[1] * v5[0]) + (v0[4] * v1[3] * v2[6] * v3[0] * v4[1] * v5[5]) + (-1 * v0[4] * v1[3] * v2[6] * v3[0] * v4[5] * v5[1]) + (-1 * v0[4] * v1[3] * v2[6] * v3[1] * v4[0] * v5[5]) + (v0[4] * v1[3] * v2[6] * v3[1] * v4[5] * v5[0]) + (v0[4] * v1[3] * v2[6] * v3[5] * v4[0] * v5[1]) + (-1 * v0[4] * v1[3] * v2[6] * v3[5] * v4[1] * v5[0]) + (v0[4] * v1[5] * v2[0] * v3[1] * v4[3] * v5[6]) + (-1 * v0[4] * v1[5] * v2[0] * v3[1] * v4[6] * v5[3]) + (-1 * v0[4] * v1[5] * v2[0] * v3[3] * v4[1] * v5[6]) + (v0[4] * v1[5] * v2[0] * v3[3] * v4[6] * v5[1]) + (v0[4] * v1[5] * v2[0] * v3[6] * v4[1] * v5[3]) + (-1 * v0[4] * v1[5] * v2[0] * v3[6] * v4[3] * v5[1]) + (-1 * v0[4] * v1[5] * v2[1] * v3[0] * v4[3] * v5[6]) + (v0[4] * v1[5] * v2[1] * v3[0] * v4[6] * v5[3]) + (v0[4] * v1[5] * v2[1] * v3[3] * v4[0] * v5[6]) + (-1 * v0[4] * v1[5] * v2[1] * v3[3] * v4[6] * v5[0]) + (-1 * v0[4] * v1[5] * v2[1] * v3[6] * v4[0] * v5[3]) + (v0[4] * v1[5] * v2[1] * v3[6] * v4[3] * v5[0]) + (v0[4] * v1[5] * v2[3] * v3[0] * v4[1] * v5[6]) + (-1 * v0[4] * v1[5] * v2[3] * v3[0] * v4[6] * v5[1]) + (-1 * v0[4] * v1[5] * v2[3] * v3[1] * v4[0] * v5[6]) + (v0[4] * v1[5] * v2[3] * v3[1] * v4[6] * v5[0]) + (v0[4] * v1[5] * v2[3] * v3[6] * v4[0] * v5[1]) + (-1 * v0[4] * v1[5] * v2[3] * v3[6] * v4[1] * v5[0]) + (-1 * v0[4] * v1[5] * v2[6] * v3[0] * v4[1] * v5[3]) + (v0[4] * v1[5] * v2[6] * v3[0] * v4[3] * v5[1]) + (v0[4] * v1[5] * v2[6] * v3[1] * v4[0] * v5[3]) + (-1 * v0[4] * v1[5] * v2[6] * v3[1] * v4[3] * v5[0]) + (-1 * v0[4] * v1[5] * v2[6] * v3[3] * v4[0] * v5[1]) + (v0[4] * v1[5] * v2[6] * v3[3] * v4[1] * v5[0]) + (-1 * v0[4] * v1[6] * v2[0] * v3[1] * v4[3] * v5[5]) + (v0[4] * v1[6] * v2[0] * v3[1] * v4[5] * v5[3]) + (v0[4] * v1[6] * v2[0] * v3[3] * v4[1] * v5[5]) + (-1 * v0[4] * v1[6] * v2[0] * v3[3] * v4[5] * v5[1]) + (-1 * v0[4] * v1[6] * v2[0] * v3[5] * v4[1] * v5[3]) + (v0[4] * v1[6] * v2[0] * v3[5] * v4[3] * v5[1]) + (v0[4] * v1[6] * v2[1] * v3[0] * v4[3] * v5[5]) + (-1 * v0[4] * v1[6] * v2[1] * v3[0] * v4[5] * v5[3]) + (-1 * v0[4] * v1[6] * v2[1] * v3[3] * v4[0] * v5[5]) + (v0[4] * v1[6] * v2[1] * v3[3] * v4[5] * v5[0]) + (v0[4] * v1[6] * v2[1] * v3[5] * v4[0] * v5[3]) + (-1 * v0[4] * v1[6] * v2[1] * v3[5] * v4[3] * v5[0]) + (-1 * v0[4] * v1[6] * v2[3] * v3[0] * v4[1] * v5[5]) + (v0[4] * v1[6] * v2[3] * v3[0] * v4[5] * v5[1]) + (v0[4] * v1[6] * v2[3] * v3[1] * v4[0] * v5[5]) + (-1 * v0[4] * v1[6] * v2[3] * v3[1] * v4[5] * v5[0]) + (-1 * v0[4] * v1[6] * v2[3] * v3[5] * v4[0] * v5[1]) + (v0[4] * v1[6] * v2[3] * v3[5] * v4[1] * v5[0]) + (v0[4] * v1[6] * v2[5] * v3[0] * v4[1] * v5[3]) + (-1 * v0[4] * v1[6] * v2[5] * v3[0] * v4[3] * v5[1]) + (-1 * v0[4] * v1[6] * v2[5] * v3[1] * v4[0] * v5[3]) + (v0[4] * v1[6] * v2[5] * v3[1] * v4[3] * v5[0]) + (v0[4] * v1[6] * v2[5] * v3[3] * v4[0] * v5[1]) + (-1 * v0[4] * v1[6] * v2[5] * v3[3] * v4[1] * v5[0]) + (v0[5] * v1[0] * v2[1] * v3[3] * v4[4] * v5[6]) + (-1 * v0[5] * v1[0] * v2[1] * v3[3] * v4[6] * v5[4]) + (-1 * v0[5] * v1[0] * v2[1] * v3[4] * v4[3] * v5[6]) + (v0[5] * v1[0] * v2[1] * v3[4] * v4[6] * v5[3]) + (v0[5] * v1[0] * v2[1] * v3[6] * v4[3] * v5[4]) + (-1 * v0[5] * v1[0] * v2[1] * v3[6] * v4[4] * v5[3]) + (-1 * v0[5] * v1[0] * v2[3] * v3[1] * v4[4] * v5[6]) + (v0[5] * v1[0] * v2[3] * v3[1] * v4[6] * v5[4]) + (v0[5] * v1[0] * v2[3] * v3[4] * v4[1] * v5[6]) + (-1 * v0[5] * v1[0] * v2[3] * v3[4] * v4[6] * v5[1]) + (-1 * v0[5] * v1[0] * v2[3] * v3[6] * v4[1] * v5[4]) + (v0[5] * v1[0] * v2[3] * v3[6] * v4[4] * v5[1]) + (v0[5] * v1[0] * v2[4] * v3[1] * v4[3] * v5[6]) + (-1 * v0[5] * v1[0] * v2[4] * v3[1] * v4[6] * v5[3]) + (-1 * v0[5] * v1[0] * v2[4] * v3[3] * v4[1] * v5[6]) + (v0[5] * v1[0] * v2[4] * v3[3] * v4[6] * v5[1]) + (v0[5] * v1[0] * v2[4] * v3[6] * v4[1] * v5[3]) + (-1 * v0[5] * v1[0] * v2[4] * v3[6] * v4[3] * v5[1]) + (-1 * v0[5] * v1[0] * v2[6] * v3[1] * v4[3] * v5[4]) + (v0[5] * v1[0] * v2[6] * v3[1] * v4[4] * v5[3]) + (v0[5] * v1[0] * v2[6] * v3[3] * v4[1] * v5[4]) + (-1 * v0[5] * v1[0] * v2[6] * v3[3] * v4[4] * v5[1]) + (-1 * v0[5] * v1[0] * v2[6] * v3[4] * v4[1] * v5[3]) + (v0[5] * v1[0] * v2[6] * v3[4] * v4[3] * v5[1]) + (-1 * v0[5] * v1[1] * v2[0] * v3[3] * v4[4] * v5[6]) + (v0[5] * v1[1] * v2[0] * v3[3] * v4[6] * v5[4]) + (v0[5] * v1[1] * v2[0] * v3[4] * v4[3] * v5[6]) + (-1 * v0[5] * v1[1] * v2[0] * v3[4] * v4[6] * v5[3]) + (-1 * v0[5] * v1[1] * v2[0] * v3[6] * v4[3] * v5[4]) + (v0[5] * v1[1] * v2[0] * v3[6] * v4[4] * v5[3]) + (v0[5] * v1[1] * v2[3] * v3[0] * v4[4] * v5[6]) + (-1 * v0[5] * v1[1] * v2[3] * v3[0] * v4[6] * v5[4]) + (-1 * v0[5] * v1[1] * v2[3] * v3[4] * v4[0] * v5[6]) + (v0[5] * v1[1] * v2[3] * v3[4] * v4[6] * v5[0]) + (v0[5] * v1[1] * v2[3] * v3[6] * v4[0] * v5[4]) + (-1 * v0[5] * v1[1] * v2[3] * v3[6] * v4[4] * v5[0]) + (-1 * v0[5] * v1[1] * v2[4] * v3[0] * v4[3] * v5[6]) + (v0[5] * v1[1] * v2[4] * v3[0] * v4[6] * v5[3]) + (v0[5] * v1[1] * v2[4] * v3[3] * v4[0] * v5[6]) + (-1 * v0[5] * v1[1] * v2[4] * v3[3] * v4[6] * v5[0]) + (-1 * v0[5] * v1[1] * v2[4] * v3[6] * v4[0] * v5[3]) + (v0[5] * v1[1] * v2[4] * v3[6] * v4[3] * v5[0]) + (v0[5] * v1[1] * v2[6] * v3[0] * v4[3] * v5[4]) + (-1 * v0[5] * v1[1] * v2[6] * v3[0] * v4[4] * v5[3]) + (-1 * v0[5] * v1[1] * v2[6] * v3[3] * v4[0] * v5[4]) + (v0[5] * v1[1] * v2[6] * v3[3] * v4[4] * v5[0]) + (v0[5] * v1[1] * v2[6] * v3[4] * v4[0] * v5[3]) + (-1 * v0[5] * v1[1] * v2[6] * v3[4] * v4[3] * v5[0]) + (v0[5] * v1[3] * v2[0] * v3[1] * v4[4] * v5[6]) + (-1 * v0[5] * v1[3] * v2[0] * v3[1] * v4[6] * v5[4]) + (-1 * v0[5] * v1[3] * v2[0] * v3[4] * v4[1] * v5[6]) + (v0[5] * v1[3] * v2[0] * v3[4] * v4[6] * v5[1]) + (v0[5] * v1[3] * v2[0] * v3[6] * v4[1] * v5[4]) + (-1 * v0[5] * v1[3] * v2[0] * v3[6] * v4[4] * v5[1]) + (-1 * v0[5] * v1[3] * v2[1] * v3[0] * v4[4] * v5[6]) + (v0[5] * v1[3] * v2[1] * v3[0] * v4[6] * v5[4]) + (v0[5] * v1[3] * v2[1] * v3[4] * v4[0] * v5[6]) + (-1 * v0[5] * v1[3] * v2[1] * v3[4] * v4[6] * v5[0]) + (-1 * v0[5] * v1[3] * v2[1] * v3[6] * v4[0] * v5[4]) + (v0[5] * v1[3] * v2[1] * v3[6] * v4[4] * v5[0]) + (v0[5] * v1[3] * v2[4] * v3[0] * v4[1] * v5[6]) + (-1 * v0[5] * v1[3] * v2[4] * v3[0] * v4[6] * v5[1]) + (-1 * v0[5] * v1[3] * v2[4] * v3[1] * v4[0] * v5[6]) + (v0[5] * v1[3] * v2[4] * v3[1] * v4[6] * v5[0]) + (v0[5] * v1[3] * v2[4] * v3[6] * v4[0] * v5[1]) + (-1 * v0[5] * v1[3] * v2[4] * v3[6] * v4[1] * v5[0]) + (-1 * v0[5] * v1[3] * v2[6] * v3[0] * v4[1] * v5[4]) + (v0[5] * v1[3] * v2[6] * v3[0] * v4[4] * v5[1]) + (v0[5] * v1[3] * v2[6] * v3[1] * v4[0] * v5[4]) + (-1 * v0[5] * v1[3] * v2[6] * v3[1] * v4[4] * v5[0]) + (-1 * v0[5] * v1[3] * v2[6] * v3[4] * v4[0] * v5[1]) + (v0[5] * v1[3] * v2[6] * v3[4] * v4[1] * v5[0]) + (-1 * v0[5] * v1[4] * v2[0] * v3[1] * v4[3] * v5[6]) + (v0[5] * v1[4] * v2[0] * v3[1] * v4[6] * v5[3]) + (v0[5] * v1[4] * v2[0] * v3[3] * v4[1] * v5[6]) + (-1 * v0[5] * v1[4] * v2[0] * v3[3] * v4[6] * v5[1]) + (-1 * v0[5] * v1[4] * v2[0] * v3[6] * v4[1] * v5[3]) + (v0[5] * v1[4] * v2[0] * v3[6] * v4[3] * v5[1]) + (v0[5] * v1[4] * v2[1] * v3[0] * v4[3] * v5[6]) + (-1 * v0[5] * v1[4] * v2[1] * v3[0] * v4[6] * v5[3]) + (-1 * v0[5] * v1[4] * v2[1] * v3[3] * v4[0] * v5[6]) + (v0[5] * v1[4] * v2[1] * v3[3] * v4[6] * v5[0]) + (v0[5] * v1[4] * v2[1] * v3[6] * v4[0] * v5[3]) + (-1 * v0[5] * v1[4] * v2[1] * v3[6] * v4[3] * v5[0]) + (-1 * v0[5] * v1[4] * v2[3] * v3[0] * v4[1] * v5[6]) + (v0[5] * v1[4] * v2[3] * v3[0] * v4[6] * v5[1]) + (v0[5] * v1[4] * v2[3] * v3[1] * v4[0] * v5[6]) + (-1 * v0[5] * v1[4] * v2[3] * v3[1] * v4[6] * v5[0]) + (-1 * v0[5] * v1[4] * v2[3] * v3[6] * v4[0] * v5[1]) + (v0[5] * v1[4] * v2[3] * v3[6] * v4[1] * v5[0]) + (v0[5] * v1[4] * v2[6] * v3[0] * v4[1] * v5[3]) + (-1 * v0[5] * v1[4] * v2[6] * v3[0] * v4[3] * v5[1]) + (-1 * v0[5] * v1[4] * v2[6] * v3[1] * v4[0] * v5[3]) + (v0[5] * v1[4] * v2[6] * v3[1] * v4[3] * v5[0]) + (v0[5] * v1[4] * v2[6] * v3[3] * v4[0] * v5[1]) + (-1 * v0[5] * v1[4] * v2[6] * v3[3] * v4[1] * v5[0]) + (v0[5] * v1[6] * v2[0] * v3[1] * v4[3] * v5[4]) + (-1 * v0[5] * v1[6] * v2[0] * v3[1] * v4[4] * v5[3]) + (-1 * v0[5] * v1[6] * v2[0] * v3[3] * v4[1] * v5[4]) + (v0[5] * v1[6] * v2[0] * v3[3] * v4[4] * v5[1]) + (v0[5] * v1[6] * v2[0] * v3[4] * v4[1] * v5[3]) + (-1 * v0[5] * v1[6] * v2[0] * v3[4] * v4[3] * v5[1]) + (-1 * v0[5] * v1[6] * v2[1] * v3[0] * v4[3] * v5[4]) + (v0[5] * v1[6] * v2[1] * v3[0] * v4[4] * v5[3]) + (v0[5] * v1[6] * v2[1] * v3[3] * v4[0] * v5[4]) + (-1 * v0[5] * v1[6] * v2[1] * v3[3] * v4[4] * v5[0]) + (-1 * v0[5] * v1[6] * v2[1] * v3[4] * v4[0] * v5[3]) + (v0[5] * v1[6] * v2[1] * v3[4] * v4[3] * v5[0]) + (v0[5] * v1[6] * v2[3] * v3[0] * v4[1] * v5[4]) + (-1 * v0[5] * v1[6] * v2[3] * v3[0] * v4[4] * v5[1]) + (-1 * v0[5] * v1[6] * v2[3] * v3[1] * v4[0] * v5[4]) + (v0[5] * v1[6] * v2[3] * v3[1] * v4[4] * v5[0]) + (v0[5] * v1[6] * v2[3] * v3[4] * v4[0] * v5[1]) + (-1 * v0[5] * v1[6] * v2[3] * v3[4] * v4[1] * v5[0]) + (-1 * v0[5] * v1[6] * v2[4] * v3[0] * v4[1] * v5[3]) + (v0[5] * v1[6] * v2[4] * v3[0] * v4[3] * v5[1]) + (v0[5] * v1[6] * v2[4] * v3[1] * v4[0] * v5[3]) + (-1 * v0[5] * v1[6] * v2[4] * v3[1] * v4[3] * v5[0]) + (-1 * v0[5] * v1[6] * v2[4] * v3[3] * v4[0] * v5[1]) + (v0[5] * v1[6] * v2[4] * v3[3] * v4[1] * v5[0]) + (-1 * v0[6] * v1[0] * v2[1] * v3[3] * v4[4] * v5[5]) + (v0[6] * v1[0] * v2[1] * v3[3] * v4[5] * v5[4]) + (v0[6] * v1[0] * v2[1] * v3[4] * v4[3] * v5[5]) + (-1 * v0[6] * v1[0] * v2[1] * v3[4] * v4[5] * v5[3]) + (-1 * v0[6] * v1[0] * v2[1] * v3[5] * v4[3] * v5[4]) + (v0[6] * v1[0] * v2[1] * v3[5] * v4[4] * v5[3]) + (v0[6] * v1[0] * v2[3] * v3[1] * v4[4] * v5[5]) + (-1 * v0[6] * v1[0] * v2[3] * v3[1] * v4[5] * v5[4]) + (-1 * v0[6] * v1[0] * v2[3] * v3[4] * v4[1] * v5[5]) + (v0[6] * v1[0] * v2[3] * v3[4] * v4[5] * v5[1]) + (v0[6] * v1[0] * v2[3] * v3[5] * v4[1] * v5[4]) + (-1 * v0[6] * v1[0] * v2[3] * v3[5] * v4[4] * v5[1]) + (-1 * v0[6] * v1[0] * v2[4] * v3[1] * v4[3] * v5[5]) + (v0[6] * v1[0] * v2[4] * v3[1] * v4[5] * v5[3]) + (v0[6] * v1[0] * v2[4] * v3[3] * v4[1] * v5[5]) + (-1 * v0[6] * v1[0] * v2[4] * v3[3] * v4[5] * v5[1]) + (-1 * v0[6] * v1[0] * v2[4] * v3[5] * v4[1] * v5[3]) + (v0[6] * v1[0] * v2[4] * v3[5] * v4[3] * v5[1]) + (v0[6] * v1[0] * v2[5] * v3[1] * v4[3] * v5[4]) + (-1 * v0[6] * v1[0] * v2[5] * v3[1] * v4[4] * v5[3]) + (-1 * v0[6] * v1[0] * v2[5] * v3[3] * v4[1] * v5[4]) + (v0[6] * v1[0] * v2[5] * v3[3] * v4[4] * v5[1]) + (v0[6] * v1[0] * v2[5] * v3[4] * v4[1] * v5[3]) + (-1 * v0[6] * v1[0] * v2[5] * v3[4] * v4[3] * v5[1]) + (v0[6] * v1[1] * v2[0] * v3[3] * v4[4] * v5[5]) + (-1 * v0[6] * v1[1] * v2[0] * v3[3] * v4[5] * v5[4]) + (-1 * v0[6] * v1[1] * v2[0] * v3[4] * v4[3] * v5[5]) + (v0[6] * v1[1] * v2[0] * v3[4] * v4[5] * v5[3]) + (v0[6] * v1[1] * v2[0] * v3[5] * v4[3] * v5[4]) + (-1 * v0[6] * v1[1] * v2[0] * v3[5] * v4[4] * v5[3]) + (-1 * v0[6] * v1[1] * v2[3] * v3[0] * v4[4] * v5[5]) + (v0[6] * v1[1] * v2[3] * v3[0] * v4[5] * v5[4]) + (v0[6] * v1[1] * v2[3] * v3[4] * v4[0] * v5[5]) + (-1 * v0[6] * v1[1] * v2[3] * v3[4] * v4[5] * v5[0]) + (-1 * v0[6] * v1[1] * v2[3] * v3[5] * v4[0] * v5[4]) + (v0[6] * v1[1] * v2[3] * v3[5] * v4[4] * v5[0]) + (v0[6] * v1[1] * v2[4] * v3[0] * v4[3] * v5[5]) + (-1 * v0[6] * v1[1] * v2[4] * v3[0] * v4[5] * v5[3]) + (-1 * v0[6] * v1[1] * v2[4] * v3[3] * v4[0] * v5[5]) + (v0[6] * v1[1] * v2[4] * v3[3] * v4[5] * v5[0]) + (v0[6] * v1[1] * v2[4] * v3[5] * v4[0] * v5[3]) + (-1 * v0[6] * v1[1] * v2[4] * v3[5] * v4[3] * v5[0]) + (-1 * v0[6] * v1[1] * v2[5] * v3[0] * v4[3] * v5[4]) + (v0[6] * v1[1] * v2[5] * v3[0] * v4[4] * v5[3]) + (v0[6] * v1[1] * v2[5] * v3[3] * v4[0] * v5[4]) + (-1 * v0[6] * v1[1] * v2[5] * v3[3] * v4[4] * v5[0]) + (-1 * v0[6] * v1[1] * v2[5] * v3[4] * v4[0] * v5[3]) + (v0[6] * v1[1] * v2[5] * v3[4] * v4[3] * v5[0]) + (-1 * v0[6] * v1[3] * v2[0] * v3[1] * v4[4] * v5[5]) + (v0[6] * v1[3] * v2[0] * v3[1] * v4[5] * v5[4]) + (v0[6] * v1[3] * v2[0] * v3[4] * v4[1] * v5[5]) + (-1 * v0[6] * v1[3] * v2[0] * v3[4] * v4[5] * v5[1]) + (-1 * v0[6] * v1[3] * v2[0] * v3[5] * v4[1] * v5[4]) + (v0[6] * v1[3] * v2[0] * v3[5] * v4[4] * v5[1]) + (v0[6] * v1[3] * v2[1] * v3[0] * v4[4] * v5[5]) + (-1 * v0[6] * v1[3] * v2[1] * v3[0] * v4[5] * v5[4]) + (-1 * v0[6] * v1[3] * v2[1] * v3[4] * v4[0] * v5[5]) + (v0[6] * v1[3] * v2[1] * v3[4] * v4[5] * v5[0]) + (v0[6] * v1[3] * v2[1] * v3[5] * v4[0] * v5[4]) + (-1 * v0[6] * v1[3] * v2[1] * v3[5] * v4[4] * v5[0]) + (-1 * v0[6] * v1[3] * v2[4] * v3[0] * v4[1] * v5[5]) + (v0[6] * v1[3] * v2[4] * v3[0] * v4[5] * v5[1]) + (v0[6] * v1[3] * v2[4] * v3[1] * v4[0] * v5[5]) + (-1 * v0[6] * v1[3] * v2[4] * v3[1] * v4[5] * v5[0]) + (-1 * v0[6] * v1[3] * v2[4] * v3[5] * v4[0] * v5[1]) + (v0[6] * v1[3] * v2[4] * v3[5] * v4[1] * v5[0]) + (v0[6] * v1[3] * v2[5] * v3[0] * v4[1] * v5[4]) + (-1 * v0[6] * v1[3] * v2[5] * v3[0] * v4[4] * v5[1]) + (-1 * v0[6] * v1[3] * v2[5] * v3[1] * v4[0] * v5[4]) + (v0[6] * v1[3] * v2[5] * v3[1] * v4[4] * v5[0]) + (v0[6] * v1[3] * v2[5] * v3[4] * v4[0] * v5[1]) + (-1 * v0[6] * v1[3] * v2[5] * v3[4] * v4[1] * v5[0]) + (v0[6] * v1[4] * v2[0] * v3[1] * v4[3] * v5[5]) + (-1 * v0[6] * v1[4] * v2[0] * v3[1] * v4[5] * v5[3]) + (-1 * v0[6] * v1[4] * v2[0] * v3[3] * v4[1] * v5[5]) + (v0[6] * v1[4] * v2[0] * v3[3] * v4[5] * v5[1]) + (v0[6] * v1[4] * v2[0] * v3[5] * v4[1] * v5[3]) + (-1 * v0[6] * v1[4] * v2[0] * v3[5] * v4[3] * v5[1]) + (-1 * v0[6] * v1[4] * v2[1] * v3[0] * v4[3] * v5[5]) + (v0[6] * v1[4] * v2[1] * v3[0] * v4[5] * v5[3]) + (v0[6] * v1[4] * v2[1] * v3[3] * v4[0] * v5[5]) + (-1 * v0[6] * v1[4] * v2[1] * v3[3] * v4[5] * v5[0]) + (-1 * v0[6] * v1[4] * v2[1] * v3[5] * v4[0] * v5[3]) + (v0[6] * v1[4] * v2[1] * v3[5] * v4[3] * v5[0]) + (v0[6] * v1[4] * v2[3] * v3[0] * v4[1] * v5[5]) + (-1 * v0[6] * v1[4] * v2[3] * v3[0] * v4[5] * v5[1]) + (-1 * v0[6] * v1[4] * v2[3] * v3[1] * v4[0] * v5[5]) + (v0[6] * v1[4] * v2[3] * v3[1] * v4[5] * v5[0]) + (v0[6] * v1[4] * v2[3] * v3[5] * v4[0] * v5[1]) + (-1 * v0[6] * v1[4] * v2[3] * v3[5] * v4[1] * v5[0]) + (-1 * v0[6] * v1[4] * v2[5] * v3[0] * v4[1] * v5[3]) + (v0[6] * v1[4] * v2[5] * v3[0] * v4[3] * v5[1]) + (v0[6] * v1[4] * v2[5] * v3[1] * v4[0] * v5[3]) + (-1 * v0[6] * v1[4] * v2[5] * v3[1] * v4[3] * v5[0]) + (-1 * v0[6] * v1[4] * v2[5] * v3[3] * v4[0] * v5[1]) + (v0[6] * v1[4] * v2[5] * v3[3] * v4[1] * v5[0]) + (-1 * v0[6] * v1[5] * v2[0] * v3[1] * v4[3] * v5[4]) + (v0[6] * v1[5] * v2[0] * v3[1] * v4[4] * v5[3]) + (v0[6] * v1[5] * v2[0] * v3[3] * v4[1] * v5[4]) + (-1 * v0[6] * v1[5] * v2[0] * v3[3] * v4[4] * v5[1]) + (-1 * v0[6] * v1[5] * v2[0] * v3[4] * v4[1] * v5[3]) + (v0[6] * v1[5] * v2[0] * v3[4] * v4[3] * v5[1]) + (v0[6] * v1[5] * v2[1] * v3[0] * v4[3] * v5[4]) + (-1 * v0[6] * v1[5] * v2[1] * v3[0] * v4[4] * v5[3]) + (-1 * v0[6] * v1[5] * v2[1] * v3[3] * v4[0] * v5[4]) + (v0[6] * v1[5] * v2[1] * v3[3] * v4[4] * v5[0]) + (v0[6] * v1[5] * v2[1] * v3[4] * v4[0] * v5[3]) + (-1 * v0[6] * v1[5] * v2[1] * v3[4] * v4[3] * v5[0]) + (-1 * v0[6] * v1[5] * v2[3] * v3[0] * v4[1] * v5[4]) + (v0[6] * v1[5] * v2[3] * v3[0] * v4[4] * v5[1]) + (v0[6] * v1[5] * v2[3] * v3[1] * v4[0] * v5[4]) + (-1 * v0[6] * v1[5] * v2[3] * v3[1] * v4[4] * v5[0]) + (-1 * v0[6] * v1[5] * v2[3] * v3[4] * v4[0] * v5[1]) + (v0[6] * v1[5] * v2[3] * v3[4] * v4[1] * v5[0]) + (v0[6] * v1[5] * v2[4] * v3[0] * v4[1] * v5[3]) + (-1 * v0[6] * v1[5] * v2[4] * v3[0] * v4[3] * v5[1]) + (-1 * v0[6] * v1[5] * v2[4] * v3[1] * v4[0] * v5[3]) + (v0[6] * v1[5] * v2[4] * v3[1] * v4[3] * v5[0]) + (v0[6] * v1[5] * v2[4] * v3[3] * v4[0] * v5[1]) + (-1 * v0[6] * v1[5] * v2[4] * v3[3] * v4[1] * v5[0]);
r0[3] = (-1 * v0[0] * v1[1] * v2[2] * v3[4] * v4[5] * v5[6]) + (v0[0] * v1[1] * v2[2] * v3[4] * v4[6] * v5[5]) + (v0[0] * v1[1] * v2[2] * v3[5] * v4[4] * v5[6]) + (-1 * v0[0] * v1[1] * v2[2] * v3[5] * v4[6] * v5[4]) + (-1 * v0[0] * v1[1] * v2[2] * v3[6] * v4[4] * v5[5]) + (v0[0] * v1[1] * v2[2] * v3[6] * v4[5] * v5[4]) + (v0[0] * v1[1] * v2[4] * v3[2] * v4[5] * v5[6]) + (-1 * v0[0] * v1[1] * v2[4] * v3[2] * v4[6] * v5[5]) + (-1 * v0[0] * v1[1] * v2[4] * v3[5] * v4[2] * v5[6]) + (v0[0] * v1[1] * v2[4] * v3[5] * v4[6] * v5[2]) + (v0[0] * v1[1] * v2[4] * v3[6] * v4[2] * v5[5]) + (-1 * v0[0] * v1[1] * v2[4] * v3[6] * v4[5] * v5[2]) + (-1 * v0[0] * v1[1] * v2[5] * v3[2] * v4[4] * v5[6]) + (v0[0] * v1[1] * v2[5] * v3[2] * v4[6] * v5[4]) + (v0[0] * v1[1] * v2[5] * v3[4] * v4[2] * v5[6]) + (-1 * v0[0] * v1[1] * v2[5] * v3[4] * v4[6] * v5[2]) + (-1 * v0[0] * v1[1] * v2[5] * v3[6] * v4[2] * v5[4]) + (v0[0] * v1[1] * v2[5] * v3[6] * v4[4] * v5[2]) + (v0[0] * v1[1] * v2[6] * v3[2] * v4[4] * v5[5]) + (-1 * v0[0] * v1[1] * v2[6] * v3[2] * v4[5] * v5[4]) + (-1 * v0[0] * v1[1] * v2[6] * v3[4] * v4[2] * v5[5]) + (v0[0] * v1[1] * v2[6] * v3[4] * v4[5] * v5[2]) + (v0[0] * v1[1] * v2[6] * v3[5] * v4[2] * v5[4]) + (-1 * v0[0] * v1[1] * v2[6] * v3[5] * v4[4] * v5[2]) + (v0[0] * v1[2] * v2[1] * v3[4] * v4[5] * v5[6]) + (-1 * v0[0] * v1[2] * v2[1] * v3[4] * v4[6] * v5[5]) + (-1 * v0[0] * v1[2] * v2[1] * v3[5] * v4[4] * v5[6]) + (v0[0] * v1[2] * v2[1] * v3[5] * v4[6] * v5[4]) + (v0[0] * v1[2] * v2[1] * v3[6] * v4[4] * v5[5]) + (-1 * v0[0] * v1[2] * v2[1] * v3[6] * v4[5] * v5[4]) + (-1 * v0[0] * v1[2] * v2[4] * v3[1] * v4[5] * v5[6]) + (v0[0] * v1[2] * v2[4] * v3[1] * v4[6] * v5[5]) + (v0[0] * v1[2] * v2[4] * v3[5] * v4[1] * v5[6]) + (-1 * v0[0] * v1[2] * v2[4] * v3[5] * v4[6] * v5[1]) + (-1 * v0[0] * v1[2] * v2[4] * v3[6] * v4[1] * v5[5]) + (v0[0] * v1[2] * v2[4] * v3[6] * v4[5] * v5[1]) + (v0[0] * v1[2] * v2[5] * v3[1] * v4[4] * v5[6]) + (-1 * v0[0] * v1[2] * v2[5] * v3[1] * v4[6] * v5[4]) + (-1 * v0[0] * v1[2] * v2[5] * v3[4] * v4[1] * v5[6]) + (v0[0] * v1[2] * v2[5] * v3[4] * v4[6] * v5[1]) + (v0[0] * v1[2] * v2[5] * v3[6] * v4[1] * v5[4]) + (-1 * v0[0] * v1[2] * v2[5] * v3[6] * v4[4] * v5[1]) + (-1 * v0[0] * v1[2] * v2[6] * v3[1] * v4[4] * v5[5]) + (v0[0] * v1[2] * v2[6] * v3[1] * v4[5] * v5[4]) + (v0[0] * v1[2] * v2[6] * v3[4] * v4[1] * v5[5]) + (-1 * v0[0] * v1[2] * v2[6] * v3[4] * v4[5] * v5[1]) + (-1 * v0[0] * v1[2] * v2[6] * v3[5] * v4[1] * v5[4]) + (v0[0] * v1[2] * v2[6] * v3[5] * v4[4] * v5[1]) + (-1 * v0[0] * v1[4] * v2[1] * v3[2] * v4[5] * v5[6]) + (v0[0] * v1[4] * v2[1] * v3[2] * v4[6] * v5[5]) + (v0[0] * v1[4] * v2[1] * v3[5] * v4[2] * v5[6]) + (-1 * v0[0] * v1[4] * v2[1] * v3[5] * v4[6] * v5[2]) + (-1 * v0[0] * v1[4] * v2[1] * v3[6] * v4[2] * v5[5]) + (v0[0] * v1[4] * v2[1] * v3[6] * v4[5] * v5[2]) + (v0[0] * v1[4] * v2[2] * v3[1] * v4[5] * v5[6]) + (-1 * v0[0] * v1[4] * v2[2] * v3[1] * v4[6] * v5[5]) + (-1 * v0[0] * v1[4] * v2[2] * v3[5] * v4[1] * v5[6]) + (v0[0] * v1[4] * v2[2] * v3[5] * v4[6] * v5[1]) + (v0[0] * v1[4] * v2[2] * v3[6] * v4[1] * v5[5]) + (-1 * v0[0] * v1[4] * v2[2] * v3[6] * v4[5] * v5[1]) + (-1 * v0[0] * v1[4] * v2[5] * v3[1] * v4[2] * v5[6]) + (v0[0] * v1[4] * v2[5] * v3[1] * v4[6] * v5[2]) + (v0[0] * v1[4] * v2[5] * v3[2] * v4[1] * v5[6]) + (-1 * v0[0] * v1[4] * v2[5] * v3[2] * v4[6] * v5[1]) + (-1 * v0[0] * v1[4] * v2[5] * v3[6] * v4[1] * v5[2]) + (v0[0] * v1[4] * v2[5] * v3[6] * v4[2] * v5[1]) + (v0[0] * v1[4] * v2[6] * v3[1] * v4[2] * v5[5]) + (-1 * v0[0] * v1[4] * v2[6] * v3[1] * v4[5] * v5[2]) + (-1 * v0[0] * v1[4] * v2[6] * v3[2] * v4[1] * v5[5]) + (v0[0] * v1[4] * v2[6] * v3[2] * v4[5] * v5[1]) + (v0[0] * v1[4] * v2[6] * v3[5] * v4[1] * v5[2]) + (-1 * v0[0] * v1[4] * v2[6] * v3[5] * v4[2] * v5[1]) + (v0[0] * v1[5] * v2[1] * v3[2] * v4[4] * v5[6]) + (-1 * v0[0] * v1[5] * v2[1] * v3[2] * v4[6] * v5[4]) + (-1 * v0[0] * v1[5] * v2[1] * v3[4] * v4[2] * v5[6]) + (v0[0] * v1[5] * v2[1] * v3[4] * v4[6] * v5[2]) + (v0[0] * v1[5] * v2[1] * v3[6] * v4[2] * v5[4]) + (-1 * v0[0] * v1[5] * v2[1] * v3[6] * v4[4] * v5[2]) + (-1 * v0[0] * v1[5] * v2[2] * v3[1] * v4[4] * v5[6]) + (v0[0] * v1[5] * v2[2] * v3[1] * v4[6] * v5[4]) + (v0[0] * v1[5] * v2[2] * v3[4] * v4[1] * v5[6]) + (-1 * v0[0] * v1[5] * v2[2] * v3[4] * v4[6] * v5[1]) + (-1 * v0[0] * v1[5] * v2[2] * v3[6] * v4[1] * v5[4]) + (v0[0] * v1[5] * v2[2] * v3[6] * v4[4] * v5[1]) + (v0[0] * v1[5] * v2[4] * v3[1] * v4[2] * v5[6]) + (-1 * v0[0] * v1[5] * v2[4] * v3[1] * v4[6] * v5[2]) + (-1 * v0[0] * v1[5] * v2[4] * v3[2] * v4[1] * v5[6]) + (v0[0] * v1[5] * v2[4] * v3[2] * v4[6] * v5[1]) + (v0[0] * v1[5] * v2[4] * v3[6] * v4[1] * v5[2]) + (-1 * v0[0] * v1[5] * v2[4] * v3[6] * v4[2] * v5[1]) + (-1 * v0[0] * v1[5] * v2[6] * v3[1] * v4[2] * v5[4]) + (v0[0] * v1[5] * v2[6] * v3[1] * v4[4] * v5[2]) + (v0[0] * v1[5] * v2[6] * v3[2] * v4[1] * v5[4]) + (-1 * v0[0] * v1[5] * v2[6] * v3[2] * v4[4] * v5[1]) + (-1 * v0[0] * v1[5] * v2[6] * v3[4] * v4[1] * v5[2]) + (v0[0] * v1[5] * v2[6] * v3[4] * v4[2] * v5[1]) + (-1 * v0[0] * v1[6] * v2[1] * v3[2] * v4[4] * v5[5]) + (v0[0] * v1[6] * v2[1] * v3[2] * v4[5] * v5[4]) + (v0[0] * v1[6] * v2[1] * v3[4] * v4[2] * v5[5]) + (-1 * v0[0] * v1[6] * v2[1] * v3[4] * v4[5] * v5[2]) + (-1 * v0[0] * v1[6] * v2[1] * v3[5] * v4[2] * v5[4]) + (v0[0] * v1[6] * v2[1] * v3[5] * v4[4] * v5[2]) + (v0[0] * v1[6] * v2[2] * v3[1] * v4[4] * v5[5]) + (-1 * v0[0] * v1[6] * v2[2] * v3[1] * v4[5] * v5[4]) + (-1 * v0[0] * v1[6] * v2[2] * v3[4] * v4[1] * v5[5]) + (v0[0] * v1[6] * v2[2] * v3[4] * v4[5] * v5[1]) + (v0[0] * v1[6] * v2[2] * v3[5] * v4[1] * v5[4]) + (-1 * v0[0] * v1[6] * v2[2] * v3[5] * v4[4] * v5[1]) + (-1 * v0[0] * v1[6] * v2[4] * v3[1] * v4[2] * v5[5]) + (v0[0] * v1[6] * v2[4] * v3[1] * v4[5] * v5[2]) + (v0[0] * v1[6] * v2[4] * v3[2] * v4[1] * v5[5]) + (-1 * v0[0] * v1[6] * v2[4] * v3[2] * v4[5] * v5[1]) + (-1 * v0[0] * v1[6] * v2[4] * v3[5] * v4[1] * v5[2]) + (v0[0] * v1[6] * v2[4] * v3[5] * v4[2] * v5[1]) + (v0[0] * v1[6] * v2[5] * v3[1] * v4[2] * v5[4]) + (-1 * v0[0] * v1[6] * v2[5] * v3[1] * v4[4] * v5[2]) + (-1 * v0[0] * v1[6] * v2[5] * v3[2] * v4[1] * v5[4]) + (v0[0] * v1[6] * v2[5] * v3[2] * v4[4] * v5[1]) + (v0[0] * v1[6] * v2[5] * v3[4] * v4[1] * v5[2]) + (-1 * v0[0] * v1[6] * v2[5] * v3[4] * v4[2] * v5[1]) + (v0[1] * v1[0] * v2[2] * v3[4] * v4[5] * v5[6]) + (-1 * v0[1] * v1[0] * v2[2] * v3[4] * v4[6] * v5[5]) + (-1 * v0[1] * v1[0] * v2[2] * v3[5] * v4[4] * v5[6]) + (v0[1] * v1[0] * v2[2] * v3[5] * v4[6] * v5[4]) + (v0[1] * v1[0] * v2[2] * v3[6] * v4[4] * v5[5]) + (-1 * v0[1] * v1[0] * v2[2] * v3[6] * v4[5] * v5[4]) + (-1 * v0[1] * v1[0] * v2[4] * v3[2] * v4[5] * v5[6]) + (v0[1] * v1[0] * v2[4] * v3[2] * v4[6] * v5[5]) + (v0[1] * v1[0] * v2[4] * v3[5] * v4[2] * v5[6]) + (-1 * v0[1] * v1[0] * v2[4] * v3[5] * v4[6] * v5[2]) + (-1 * v0[1] * v1[0] * v2[4] * v3[6] * v4[2] * v5[5]) + (v0[1] * v1[0] * v2[4] * v3[6] * v4[5] * v5[2]) + (v0[1] * v1[0] * v2[5] * v3[2] * v4[4] * v5[6]) + (-1 * v0[1] * v1[0] * v2[5] * v3[2] * v4[6] * v5[4]) + (-1 * v0[1] * v1[0] * v2[5] * v3[4] * v4[2] * v5[6]) + (v0[1] * v1[0] * v2[5] * v3[4] * v4[6] * v5[2]) + (v0[1] * v1[0] * v2[5] * v3[6] * v4[2] * v5[4]) + (-1 * v0[1] * v1[0] * v2[5] * v3[6] * v4[4] * v5[2]) + (-1 * v0[1] * v1[0] * v2[6] * v3[2] * v4[4] * v5[5]) + (v0[1] * v1[0] * v2[6] * v3[2] * v4[5] * v5[4]) + (v0[1] * v1[0] * v2[6] * v3[4] * v4[2] * v5[5]) + (-1 * v0[1] * v1[0] * v2[6] * v3[4] * v4[5] * v5[2]) + (-1 * v0[1] * v1[0] * v2[6] * v3[5] * v4[2] * v5[4]) + (v0[1] * v1[0] * v2[6] * v3[5] * v4[4] * v5[2]) + (-1 * v0[1] * v1[2] * v2[0] * v3[4] * v4[5] * v5[6]) + (v0[1] * v1[2] * v2[0] * v3[4] * v4[6] * v5[5]) + (v0[1] * v1[2] * v2[0] * v3[5] * v4[4] * v5[6]) + (-1 * v0[1] * v1[2] * v2[0] * v3[5] * v4[6] * v5[4]) + (-1 * v0[1] * v1[2] * v2[0] * v3[6] * v4[4] * v5[5]) + (v0[1] * v1[2] * v2[0] * v3[6] * v4[5] * v5[4]) + (v0[1] * v1[2] * v2[4] * v3[0] * v4[5] * v5[6]) + (-1 * v0[1] * v1[2] * v2[4] * v3[0] * v4[6] * v5[5]) + (-1 * v0[1] * v1[2] * v2[4] * v3[5] * v4[0] * v5[6]) + (v0[1] * v1[2] * v2[4] * v3[5] * v4[6] * v5[0]) + (v0[1] * v1[2] * v2[4] * v3[6] * v4[0] * v5[5]) + (-1 * v0[1] * v1[2] * v2[4] * v3[6] * v4[5] * v5[0]) + (-1 * v0[1] * v1[2] * v2[5] * v3[0] * v4[4] * v5[6]) + (v0[1] * v1[2] * v2[5] * v3[0] * v4[6] * v5[4]) + (v0[1] * v1[2] * v2[5] * v3[4] * v4[0] * v5[6]) + (-1 * v0[1] * v1[2] * v2[5] * v3[4] * v4[6] * v5[0]) + (-1 * v0[1] * v1[2] * v2[5] * v3[6] * v4[0] * v5[4]) + (v0[1] * v1[2] * v2[5] * v3[6] * v4[4] * v5[0]) + (v0[1] * v1[2] * v2[6] * v3[0] * v4[4] * v5[5]) + (-1 * v0[1] * v1[2] * v2[6] * v3[0] * v4[5] * v5[4]) + (-1 * v0[1] * v1[2] * v2[6] * v3[4] * v4[0] * v5[5]) + (v0[1] * v1[2] * v2[6] * v3[4] * v4[5] * v5[0]) + (v0[1] * v1[2] * v2[6] * v3[5] * v4[0] * v5[4]) + (-1 * v0[1] * v1[2] * v2[6] * v3[5] * v4[4] * v5[0]) + (v0[1] * v1[4] * v2[0] * v3[2] * v4[5] * v5[6]) + (-1 * v0[1] * v1[4] * v2[0] * v3[2] * v4[6] * v5[5]) + (-1 * v0[1] * v1[4] * v2[0] * v3[5] * v4[2] * v5[6]) + (v0[1] * v1[4] * v2[0] * v3[5] * v4[6] * v5[2]) + (v0[1] * v1[4] * v2[0] * v3[6] * v4[2] * v5[5]) + (-1 * v0[1] * v1[4] * v2[0] * v3[6] * v4[5] * v5[2]) + (-1 * v0[1] * v1[4] * v2[2] * v3[0] * v4[5] * v5[6]) + (v0[1] * v1[4] * v2[2] * v3[0] * v4[6] * v5[5]) + (v0[1] * v1[4] * v2[2] * v3[5] * v4[0] * v5[6]) + (-1 * v0[1] * v1[4] * v2[2] * v3[5] * v4[6] * v5[0]) + (-1 * v0[1] * v1[4] * v2[2] * v3[6] * v4[0] * v5[5]) + (v0[1] * v1[4] * v2[2] * v3[6] * v4[5] * v5[0]) + (v0[1] * v1[4] * v2[5] * v3[0] * v4[2] * v5[6]) + (-1 * v0[1] * v1[4] * v2[5] * v3[0] * v4[6] * v5[2]) + (-1 * v0[1] * v1[4] * v2[5] * v3[2] * v4[0] * v5[6]) + (v0[1] * v1[4] * v2[5] * v3[2] * v4[6] * v5[0]) + (v0[1] * v1[4] * v2[5] * v3[6] * v4[0] * v5[2]) + (-1 * v0[1] * v1[4] * v2[5] * v3[6] * v4[2] * v5[0]) + (-1 * v0[1] * v1[4] * v2[6] * v3[0] * v4[2] * v5[5]) + (v0[1] * v1[4] * v2[6] * v3[0] * v4[5] * v5[2]) + (v0[1] * v1[4] * v2[6] * v3[2] * v4[0] * v5[5]) + (-1 * v0[1] * v1[4] * v2[6] * v3[2] * v4[5] * v5[0]) + (-1 * v0[1] * v1[4] * v2[6] * v3[5] * v4[0] * v5[2]) + (v0[1] * v1[4] * v2[6] * v3[5] * v4[2] * v5[0]) + (-1 * v0[1] * v1[5] * v2[0] * v3[2] * v4[4] * v5[6]) + (v0[1] * v1[5] * v2[0] * v3[2] * v4[6] * v5[4]) + (v0[1] * v1[5] * v2[0] * v3[4] * v4[2] * v5[6]) + (-1 * v0[1] * v1[5] * v2[0] * v3[4] * v4[6] * v5[2]) + (-1 * v0[1] * v1[5] * v2[0] * v3[6] * v4[2] * v5[4]) + (v0[1] * v1[5] * v2[0] * v3[6] * v4[4] * v5[2]) + (v0[1] * v1[5] * v2[2] * v3[0] * v4[4] * v5[6]) + (-1 * v0[1] * v1[5] * v2[2] * v3[0] * v4[6] * v5[4]) + (-1 * v0[1] * v1[5] * v2[2] * v3[4] * v4[0] * v5[6]) + (v0[1] * v1[5] * v2[2] * v3[4] * v4[6] * v5[0]) + (v0[1] * v1[5] * v2[2] * v3[6] * v4[0] * v5[4]) + (-1 * v0[1] * v1[5] * v2[2] * v3[6] * v4[4] * v5[0]) + (-1 * v0[1] * v1[5] * v2[4] * v3[0] * v4[2] * v5[6]) + (v0[1] * v1[5] * v2[4] * v3[0] * v4[6] * v5[2]) + (v0[1] * v1[5] * v2[4] * v3[2] * v4[0] * v5[6]) + (-1 * v0[1] * v1[5] * v2[4] * v3[2] * v4[6] * v5[0]) + (-1 * v0[1] * v1[5] * v2[4] * v3[6] * v4[0] * v5[2]) + (v0[1] * v1[5] * v2[4] * v3[6] * v4[2] * v5[0]) + (v0[1] * v1[5] * v2[6] * v3[0] * v4[2] * v5[4]) + (-1 * v0[1] * v1[5] * v2[6] * v3[0] * v4[4] * v5[2]) + (-1 * v0[1] * v1[5] * v2[6] * v3[2] * v4[0] * v5[4]) + (v0[1] * v1[5] * v2[6] * v3[2] * v4[4] * v5[0]) + (v0[1] * v1[5] * v2[6] * v3[4] * v4[0] * v5[2]) + (-1 * v0[1] * v1[5] * v2[6] * v3[4] * v4[2] * v5[0]) + (v0[1] * v1[6] * v2[0] * v3[2] * v4[4] * v5[5]) + (-1 * v0[1] * v1[6] * v2[0] * v3[2] * v4[5] * v5[4]) + (-1 * v0[1] * v1[6] * v2[0] * v3[4] * v4[2] * v5[5]) + (v0[1] * v1[6] * v2[0] * v3[4] * v4[5] * v5[2]) + (v0[1] * v1[6] * v2[0] * v3[5] * v4[2] * v5[4]) + (-1 * v0[1] * v1[6] * v2[0] * v3[5] * v4[4] * v5[2]) + (-1 * v0[1] * v1[6] * v2[2] * v3[0] * v4[4] * v5[5]) + (v0[1] * v1[6] * v2[2] * v3[0] * v4[5] * v5[4]) + (v0[1] * v1[6] * v2[2] * v3[4] * v4[0] * v5[5]) + (-1 * v0[1] * v1[6] * v2[2] * v3[4] * v4[5] * v5[0]) + (-1 * v0[1] * v1[6] * v2[2] * v3[5] * v4[0] * v5[4]) + (v0[1] * v1[6] * v2[2] * v3[5] * v4[4] * v5[0]) + (v0[1] * v1[6] * v2[4] * v3[0] * v4[2] * v5[5]) + (-1 * v0[1] * v1[6] * v2[4] * v3[0] * v4[5] * v5[2]) + (-1 * v0[1] * v1[6] * v2[4] * v3[2] * v4[0] * v5[5]) + (v0[1] * v1[6] * v2[4] * v3[2] * v4[5] * v5[0]) + (v0[1] * v1[6] * v2[4] * v3[5] * v4[0] * v5[2]) + (-1 * v0[1] * v1[6] * v2[4] * v3[5] * v4[2] * v5[0]) + (-1 * v0[1] * v1[6] * v2[5] * v3[0] * v4[2] * v5[4]) + (v0[1] * v1[6] * v2[5] * v3[0] * v4[4] * v5[2]) + (v0[1] * v1[6] * v2[5] * v3[2] * v4[0] * v5[4]) + (-1 * v0[1] * v1[6] * v2[5] * v3[2] * v4[4] * v5[0]) + (-1 * v0[1] * v1[6] * v2[5] * v3[4] * v4[0] * v5[2]) + (v0[1] * v1[6] * v2[5] * v3[4] * v4[2] * v5[0]) + (-1 * v0[2] * v1[0] * v2[1] * v3[4] * v4[5] * v5[6]) + (v0[2] * v1[0] * v2[1] * v3[4] * v4[6] * v5[5]) + (v0[2] * v1[0] * v2[1] * v3[5] * v4[4] * v5[6]) + (-1 * v0[2] * v1[0] * v2[1] * v3[5] * v4[6] * v5[4]) + (-1 * v0[2] * v1[0] * v2[1] * v3[6] * v4[4] * v5[5]) + (v0[2] * v1[0] * v2[1] * v3[6] * v4[5] * v5[4]) + (v0[2] * v1[0] * v2[4] * v3[1] * v4[5] * v5[6]) + (-1 * v0[2] * v1[0] * v2[4] * v3[1] * v4[6] * v5[5]) + (-1 * v0[2] * v1[0] * v2[4] * v3[5] * v4[1] * v5[6]) + (v0[2] * v1[0] * v2[4] * v3[5] * v4[6] * v5[1]) + (v0[2] * v1[0] * v2[4] * v3[6] * v4[1] * v5[5]) + (-1 * v0[2] * v1[0] * v2[4] * v3[6] * v4[5] * v5[1]) + (-1 * v0[2] * v1[0] * v2[5] * v3[1] * v4[4] * v5[6]) + (v0[2] * v1[0] * v2[5] * v3[1] * v4[6] * v5[4]) + (v0[2] * v1[0] * v2[5] * v3[4] * v4[1] * v5[6]) + (-1 * v0[2] * v1[0] * v2[5] * v3[4] * v4[6] * v5[1]) + (-1 * v0[2] * v1[0] * v2[5] * v3[6] * v4[1] * v5[4]) + (v0[2] * v1[0] * v2[5] * v3[6] * v4[4] * v5[1]) + (v0[2] * v1[0] * v2[6] * v3[1] * v4[4] * v5[5]) + (-1 * v0[2] * v1[0] * v2[6] * v3[1] * v4[5] * v5[4]) + (-1 * v0[2] * v1[0] * v2[6] * v3[4] * v4[1] * v5[5]) + (v0[2] * v1[0] * v2[6] * v3[4] * v4[5] * v5[1]) + (v0[2] * v1[0] * v2[6] * v3[5] * v4[1] * v5[4]) + (-1 * v0[2] * v1[0] * v2[6] * v3[5] * v4[4] * v5[1]) + (v0[2] * v1[1] * v2[0] * v3[4] * v4[5] * v5[6]) + (-1 * v0[2] * v1[1] * v2[0] * v3[4] * v4[6] * v5[5]) + (-1 * v0[2] * v1[1] * v2[0] * v3[5] * v4[4] * v5[6]) + (v0[2] * v1[1] * v2[0] * v3[5] * v4[6] * v5[4]) + (v0[2] * v1[1] * v2[0] * v3[6] * v4[4] * v5[5]) + (-1 * v0[2] * v1[1] * v2[0] * v3[6] * v4[5] * v5[4]) + (-1 * v0[2] * v1[1] * v2[4] * v3[0] * v4[5] * v5[6]) + (v0[2] * v1[1] * v2[4] * v3[0] * v4[6] * v5[5]) + (v0[2] * v1[1] * v2[4] * v3[5] * v4[0] * v5[6]) + (-1 * v0[2] * v1[1] * v2[4] * v3[5] * v4[6] * v5[0]) + (-1 * v0[2] * v1[1] * v2[4] * v3[6] * v4[0] * v5[5]) + (v0[2] * v1[1] * v2[4] * v3[6] * v4[5] * v5[0]) + (v0[2] * v1[1] * v2[5] * v3[0] * v4[4] * v5[6]) + (-1 * v0[2] * v1[1] * v2[5] * v3[0] * v4[6] * v5[4]) + (-1 * v0[2] * v1[1] * v2[5] * v3[4] * v4[0] * v5[6]) + (v0[2] * v1[1] * v2[5] * v3[4] * v4[6] * v5[0]) + (v0[2] * v1[1] * v2[5] * v3[6] * v4[0] * v5[4]) + (-1 * v0[2] * v1[1] * v2[5] * v3[6] * v4[4] * v5[0]) + (-1 * v0[2] * v1[1] * v2[6] * v3[0] * v4[4] * v5[5]) + (v0[2] * v1[1] * v2[6] * v3[0] * v4[5] * v5[4]) + (v0[2] * v1[1] * v2[6] * v3[4] * v4[0] * v5[5]) + (-1 * v0[2] * v1[1] * v2[6] * v3[4] * v4[5] * v5[0]) + (-1 * v0[2] * v1[1] * v2[6] * v3[5] * v4[0] * v5[4]) + (v0[2] * v1[1] * v2[6] * v3[5] * v4[4] * v5[0]) + (-1 * v0[2] * v1[4] * v2[0] * v3[1] * v4[5] * v5[6]) + (v0[2] * v1[4] * v2[0] * v3[1] * v4[6] * v5[5]) + (v0[2] * v1[4] * v2[0] * v3[5] * v4[1] * v5[6]) + (-1 * v0[2] * v1[4] * v2[0] * v3[5] * v4[6] * v5[1]) + (-1 * v0[2] * v1[4] * v2[0] * v3[6] * v4[1] * v5[5]) + (v0[2] * v1[4] * v2[0] * v3[6] * v4[5] * v5[1]) + (v0[2] * v1[4] * v2[1] * v3[0] * v4[5] * v5[6]) + (-1 * v0[2] * v1[4] * v2[1] * v3[0] * v4[6] * v5[5]) + (-1 * v0[2] * v1[4] * v2[1] * v3[5] * v4[0] * v5[6]) + (v0[2] * v1[4] * v2[1] * v3[5] * v4[6] * v5[0]) + (v0[2] * v1[4] * v2[1] * v3[6] * v4[0] * v5[5]) + (-1 * v0[2] * v1[4] * v2[1] * v3[6] * v4[5] * v5[0]) + (-1 * v0[2] * v1[4] * v2[5] * v3[0] * v4[1] * v5[6]) + (v0[2] * v1[4] * v2[5] * v3[0] * v4[6] * v5[1]) + (v0[2] * v1[4] * v2[5] * v3[1] * v4[0] * v5[6]) + (-1 * v0[2] * v1[4] * v2[5] * v3[1] * v4[6] * v5[0]) + (-1 * v0[2] * v1[4] * v2[5] * v3[6] * v4[0] * v5[1]) + (v0[2] * v1[4] * v2[5] * v3[6] * v4[1] * v5[0]) + (v0[2] * v1[4] * v2[6] * v3[0] * v4[1] * v5[5]) + (-1 * v0[2] * v1[4] * v2[6] * v3[0] * v4[5] * v5[1]) + (-1 * v0[2] * v1[4] * v2[6] * v3[1] * v4[0] * v5[5]) + (v0[2] * v1[4] * v2[6] * v3[1] * v4[5] * v5[0]) + (v0[2] * v1[4] * v2[6] * v3[5] * v4[0] * v5[1]) + (-1 * v0[2] * v1[4] * v2[6] * v3[5] * v4[1] * v5[0]) + (v0[2] * v1[5] * v2[0] * v3[1] * v4[4] * v5[6]) + (-1 * v0[2] * v1[5] * v2[0] * v3[1] * v4[6] * v5[4]) + (-1 * v0[2] * v1[5] * v2[0] * v3[4] * v4[1] * v5[6]) + (v0[2] * v1[5] * v2[0] * v3[4] * v4[6] * v5[1]) + (v0[2] * v1[5] * v2[0] * v3[6] * v4[1] * v5[4]) + (-1 * v0[2] * v1[5] * v2[0] * v3[6] * v4[4] * v5[1]) + (-1 * v0[2] * v1[5] * v2[1] * v3[0] * v4[4] * v5[6]) + (v0[2] * v1[5] * v2[1] * v3[0] * v4[6] * v5[4]) + (v0[2] * v1[5] * v2[1] * v3[4] * v4[0] * v5[6]) + (-1 * v0[2] * v1[5] * v2[1] * v3[4] * v4[6] * v5[0]) + (-1 * v0[2] * v1[5] * v2[1] * v3[6] * v4[0] * v5[4]) + (v0[2] * v1[5] * v2[1] * v3[6] * v4[4] * v5[0]) + (v0[2] * v1[5] * v2[4] * v3[0] * v4[1] * v5[6]) + (-1 * v0[2] * v1[5] * v2[4] * v3[0] * v4[6] * v5[1]) + (-1 * v0[2] * v1[5] * v2[4] * v3[1] * v4[0] * v5[6]) + (v0[2] * v1[5] * v2[4] * v3[1] * v4[6] * v5[0]) + (v0[2] * v1[5] * v2[4] * v3[6] * v4[0] * v5[1]) + (-1 * v0[2] * v1[5] * v2[4] * v3[6] * v4[1] * v5[0]) + (-1 * v0[2] * v1[5] * v2[6] * v3[0] * v4[1] * v5[4]) + (v0[2] * v1[5] * v2[6] * v3[0] * v4[4] * v5[1]) + (v0[2] * v1[5] * v2[6] * v3[1] * v4[0] * v5[4]) + (-1 * v0[2] * v1[5] * v2[6] * v3[1] * v4[4] * v5[0]) + (-1 * v0[2] * v1[5] * v2[6] * v3[4] * v4[0] * v5[1]) + (v0[2] * v1[5] * v2[6] * v3[4] * v4[1] * v5[0]) + (-1 * v0[2] * v1[6] * v2[0] * v3[1] * v4[4] * v5[5]) + (v0[2] * v1[6] * v2[0] * v3[1] * v4[5] * v5[4]) + (v0[2] * v1[6] * v2[0] * v3[4] * v4[1] * v5[5]) + (-1 * v0[2] * v1[6] * v2[0] * v3[4] * v4[5] * v5[1]) + (-1 * v0[2] * v1[6] * v2[0] * v3[5] * v4[1] * v5[4]) + (v0[2] * v1[6] * v2[0] * v3[5] * v4[4] * v5[1]) + (v0[2] * v1[6] * v2[1] * v3[0] * v4[4] * v5[5]) + (-1 * v0[2] * v1[6] * v2[1] * v3[0] * v4[5] * v5[4]) + (-1 * v0[2] * v1[6] * v2[1] * v3[4] * v4[0] * v5[5]) + (v0[2] * v1[6] * v2[1] * v3[4] * v4[5] * v5[0]) + (v0[2] * v1[6] * v2[1] * v3[5] * v4[0] * v5[4]) + (-1 * v0[2] * v1[6] * v2[1] * v3[5] * v4[4] * v5[0]) + (-1 * v0[2] * v1[6] * v2[4] * v3[0] * v4[1] * v5[5]) + (v0[2] * v1[6] * v2[4] * v3[0] * v4[5] * v5[1]) + (v0[2] * v1[6] * v2[4] * v3[1] * v4[0] * v5[5]) + (-1 * v0[2] * v1[6] * v2[4] * v3[1] * v4[5] * v5[0]) + (-1 * v0[2] * v1[6] * v2[4] * v3[5] * v4[0] * v5[1]) + (v0[2] * v1[6] * v2[4] * v3[5] * v4[1] * v5[0]) + (v0[2] * v1[6] * v2[5] * v3[0] * v4[1] * v5[4]) + (-1 * v0[2] * v1[6] * v2[5] * v3[0] * v4[4] * v5[1]) + (-1 * v0[2] * v1[6] * v2[5] * v3[1] * v4[0] * v5[4]) + (v0[2] * v1[6] * v2[5] * v3[1] * v4[4] * v5[0]) + (v0[2] * v1[6] * v2[5] * v3[4] * v4[0] * v5[1]) + (-1 * v0[2] * v1[6] * v2[5] * v3[4] * v4[1] * v5[0]) + (v0[4] * v1[0] * v2[1] * v3[2] * v4[5] * v5[6]) + (-1 * v0[4] * v1[0] * v2[1] * v3[2] * v4[6] * v5[5]) + (-1 * v0[4] * v1[0] * v2[1] * v3[5] * v4[2] * v5[6]) + (v0[4] * v1[0] * v2[1] * v3[5] * v4[6] * v5[2]) + (v0[4] * v1[0] * v2[1] * v3[6] * v4[2] * v5[5]) + (-1 * v0[4] * v1[0] * v2[1] * v3[6] * v4[5] * v5[2]) + (-1 * v0[4] * v1[0] * v2[2] * v3[1] * v4[5] * v5[6]) + (v0[4] * v1[0] * v2[2] * v3[1] * v4[6] * v5[5]) + (v0[4] * v1[0] * v2[2] * v3[5] * v4[1] * v5[6]) + (-1 * v0[4] * v1[0] * v2[2] * v3[5] * v4[6] * v5[1]) + (-1 * v0[4] * v1[0] * v2[2] * v3[6] * v4[1] * v5[5]) + (v0[4] * v1[0] * v2[2] * v3[6] * v4[5] * v5[1]) + (v0[4] * v1[0] * v2[5] * v3[1] * v4[2] * v5[6]) + (-1 * v0[4] * v1[0] * v2[5] * v3[1] * v4[6] * v5[2]) + (-1 * v0[4] * v1[0] * v2[5] * v3[2] * v4[1] * v5[6]) + (v0[4] * v1[0] * v2[5] * v3[2] * v4[6] * v5[1]) + (v0[4] * v1[0] * v2[5] * v3[6] * v4[1] * v5[2]) + (-1 * v0[4] * v1[0] * v2[5] * v3[6] * v4[2] * v5[1]) + (-1 * v0[4] * v1[0] * v2[6] * v3[1] * v4[2] * v5[5]) + (v0[4] * v1[0] * v2[6] * v3[1] * v4[5] * v5[2]) + (v0[4] * v1[0] * v2[6] * v3[2] * v4[1] * v5[5]) + (-1 * v0[4] * v1[0] * v2[6] * v3[2] * v4[5] * v5[1]) + (-1 * v0[4] * v1[0] * v2[6] * v3[5] * v4[1] * v5[2]) + (v0[4] * v1[0] * v2[6] * v3[5] * v4[2] * v5[1]) + (-1 * v0[4] * v1[1] * v2[0] * v3[2] * v4[5] * v5[6]) + (v0[4] * v1[1] * v2[0] * v3[2] * v4[6] * v5[5]) + (v0[4] * v1[1] * v2[0] * v3[5] * v4[2] * v5[6]) + (-1 * v0[4] * v1[1] * v2[0] * v3[5] * v4[6] * v5[2]) + (-1 * v0[4] * v1[1] * v2[0] * v3[6] * v4[2] * v5[5]) + (v0[4] * v1[1] * v2[0] * v3[6] * v4[5] * v5[2]) + (v0[4] * v1[1] * v2[2] * v3[0] * v4[5] * v5[6]) + (-1 * v0[4] * v1[1] * v2[2] * v3[0] * v4[6] * v5[5]) + (-1 * v0[4] * v1[1] * v2[2] * v3[5] * v4[0] * v5[6]) + (v0[4] * v1[1] * v2[2] * v3[5] * v4[6] * v5[0]) + (v0[4] * v1[1] * v2[2] * v3[6] * v4[0] * v5[5]) + (-1 * v0[4] * v1[1] * v2[2] * v3[6] * v4[5] * v5[0]) + (-1 * v0[4] * v1[1] * v2[5] * v3[0] * v4[2] * v5[6]) + (v0[4] * v1[1] * v2[5] * v3[0] * v4[6] * v5[2]) + (v0[4] * v1[1] * v2[5] * v3[2] * v4[0] * v5[6]) + (-1 * v0[4] * v1[1] * v2[5] * v3[2] * v4[6] * v5[0]) + (-1 * v0[4] * v1[1] * v2[5] * v3[6] * v4[0] * v5[2]) + (v0[4] * v1[1] * v2[5] * v3[6] * v4[2] * v5[0]) + (v0[4] * v1[1] * v2[6] * v3[0] * v4[2] * v5[5]) + (-1 * v0[4] * v1[1] * v2[6] * v3[0] * v4[5] * v5[2]) + (-1 * v0[4] * v1[1] * v2[6] * v3[2] * v4[0] * v5[5]) + (v0[4] * v1[1] * v2[6] * v3[2] * v4[5] * v5[0]) + (v0[4] * v1[1] * v2[6] * v3[5] * v4[0] * v5[2]) + (-1 * v0[4] * v1[1] * v2[6] * v3[5] * v4[2] * v5[0]) + (v0[4] * v1[2] * v2[0] * v3[1] * v4[5] * v5[6]) + (-1 * v0[4] * v1[2] * v2[0] * v3[1] * v4[6] * v5[5]) + (-1 * v0[4] * v1[2] * v2[0] * v3[5] * v4[1] * v5[6]) + (v0[4] * v1[2] * v2[0] * v3[5] * v4[6] * v5[1]) + (v0[4] * v1[2] * v2[0] * v3[6] * v4[1] * v5[5]) + (-1 * v0[4] * v1[2] * v2[0] * v3[6] * v4[5] * v5[1]) + (-1 * v0[4] * v1[2] * v2[1] * v3[0] * v4[5] * v5[6]) + (v0[4] * v1[2] * v2[1] * v3[0] * v4[6] * v5[5]) + (v0[4] * v1[2] * v2[1] * v3[5] * v4[0] * v5[6]) + (-1 * v0[4] * v1[2] * v2[1] * v3[5] * v4[6] * v5[0]) + (-1 * v0[4] * v1[2] * v2[1] * v3[6] * v4[0] * v5[5]) + (v0[4] * v1[2] * v2[1] * v3[6] * v4[5] * v5[0]) + (v0[4] * v1[2] * v2[5] * v3[0] * v4[1] * v5[6]) + (-1 * v0[4] * v1[2] * v2[5] * v3[0] * v4[6] * v5[1]) + (-1 * v0[4] * v1[2] * v2[5] * v3[1] * v4[0] * v5[6]) + (v0[4] * v1[2] * v2[5] * v3[1] * v4[6] * v5[0]) + (v0[4] * v1[2] * v2[5] * v3[6] * v4[0] * v5[1]) + (-1 * v0[4] * v1[2] * v2[5] * v3[6] * v4[1] * v5[0]) + (-1 * v0[4] * v1[2] * v2[6] * v3[0] * v4[1] * v5[5]) + (v0[4] * v1[2] * v2[6] * v3[0] * v4[5] * v5[1]) + (v0[4] * v1[2] * v2[6] * v3[1] * v4[0] * v5[5]) + (-1 * v0[4] * v1[2] * v2[6] * v3[1] * v4[5] * v5[0]) + (-1 * v0[4] * v1[2] * v2[6] * v3[5] * v4[0] * v5[1]) + (v0[4] * v1[2] * v2[6] * v3[5] * v4[1] * v5[0]) + (-1 * v0[4] * v1[5] * v2[0] * v3[1] * v4[2] * v5[6]) + (v0[4] * v1[5] * v2[0] * v3[1] * v4[6] * v5[2]) + (v0[4] * v1[5] * v2[0] * v3[2] * v4[1] * v5[6]) + (-1 * v0[4] * v1[5] * v2[0] * v3[2] * v4[6] * v5[1]) + (-1 * v0[4] * v1[5] * v2[0] * v3[6] * v4[1] * v5[2]) + (v0[4] * v1[5] * v2[0] * v3[6] * v4[2] * v5[1]) + (v0[4] * v1[5] * v2[1] * v3[0] * v4[2] * v5[6]) + (-1 * v0[4] * v1[5] * v2[1] * v3[0] * v4[6] * v5[2]) + (-1 * v0[4] * v1[5] * v2[1] * v3[2] * v4[0] * v5[6]) + (v0[4] * v1[5] * v2[1] * v3[2] * v4[6] * v5[0]) + (v0[4] * v1[5] * v2[1] * v3[6] * v4[0] * v5[2]) + (-1 * v0[4] * v1[5] * v2[1] * v3[6] * v4[2] * v5[0]) + (-1 * v0[4] * v1[5] * v2[2] * v3[0] * v4[1] * v5[6]) + (v0[4] * v1[5] * v2[2] * v3[0] * v4[6] * v5[1]) + (v0[4] * v1[5] * v2[2] * v3[1] * v4[0] * v5[6]) + (-1 * v0[4] * v1[5] * v2[2] * v3[1] * v4[6] * v5[0]) + (-1 * v0[4] * v1[5] * v2[2] * v3[6] * v4[0] * v5[1]) + (v0[4] * v1[5] * v2[2] * v3[6] * v4[1] * v5[0]) + (v0[4] * v1[5] * v2[6] * v3[0] * v4[1] * v5[2]) + (-1 * v0[4] * v1[5] * v2[6] * v3[0] * v4[2] * v5[1]) + (-1 * v0[4] * v1[5] * v2[6] * v3[1] * v4[0] * v5[2]) + (v0[4] * v1[5] * v2[6] * v3[1] * v4[2] * v5[0]) + (v0[4] * v1[5] * v2[6] * v3[2] * v4[0] * v5[1]) + (-1 * v0[4] * v1[5] * v2[6] * v3[2] * v4[1] * v5[0]) + (v0[4] * v1[6] * v2[0] * v3[1] * v4[2] * v5[5]) + (-1 * v0[4] * v1[6] * v2[0] * v3[1] * v4[5] * v5[2]) + (-1 * v0[4] * v1[6] * v2[0] * v3[2] * v4[1] * v5[5]) + (v0[4] * v1[6] * v2[0] * v3[2] * v4[5] * v5[1]) + (v0[4] * v1[6] * v2[0] * v3[5] * v4[1] * v5[2]) + (-1 * v0[4] * v1[6] * v2[0] * v3[5] * v4[2] * v5[1]) + (-1 * v0[4] * v1[6] * v2[1] * v3[0] * v4[2] * v5[5]) + (v0[4] * v1[6] * v2[1] * v3[0] * v4[5] * v5[2]) + (v0[4] * v1[6] * v2[1] * v3[2] * v4[0] * v5[5]) + (-1 * v0[4] * v1[6] * v2[1] * v3[2] * v4[5] * v5[0]) + (-1 * v0[4] * v1[6] * v2[1] * v3[5] * v4[0] * v5[2]) + (v0[4] * v1[6] * v2[1] * v3[5] * v4[2] * v5[0]) + (v0[4] * v1[6] * v2[2] * v3[0] * v4[1] * v5[5]) + (-1 * v0[4] * v1[6] * v2[2] * v3[0] * v4[5] * v5[1]) + (-1 * v0[4] * v1[6] * v2[2] * v3[1] * v4[0] * v5[5]) + (v0[4] * v1[6] * v2[2] * v3[1] * v4[5] * v5[0]) + (v0[4] * v1[6] * v2[2] * v3[5] * v4[0] * v5[1]) + (-1 * v0[4] * v1[6] * v2[2] * v3[5] * v4[1] * v5[0]) + (-1 * v0[4] * v1[6] * v2[5] * v3[0] * v4[1] * v5[2]) + (v0[4] * v1[6] * v2[5] * v3[0] * v4[2] * v5[1]) + (v0[4] * v1[6] * v2[5] * v3[1] * v4[0] * v5[2]) + (-1 * v0[4] * v1[6] * v2[5] * v3[1] * v4[2] * v5[0]) + (-1 * v0[4] * v1[6] * v2[5] * v3[2] * v4[0] * v5[1]) + (v0[4] * v1[6] * v2[5] * v3[2] * v4[1] * v5[0]) + (-1 * v0[5] * v1[0] * v2[1] * v3[2] * v4[4] * v5[6]) + (v0[5] * v1[0] * v2[1] * v3[2] * v4[6] * v5[4]) + (v0[5] * v1[0] * v2[1] * v3[4] * v4[2] * v5[6]) + (-1 * v0[5] * v1[0] * v2[1] * v3[4] * v4[6] * v5[2]) + (-1 * v0[5] * v1[0] * v2[1] * v3[6] * v4[2] * v5[4]) + (v0[5] * v1[0] * v2[1] * v3[6] * v4[4] * v5[2]) + (v0[5] * v1[0] * v2[2] * v3[1] * v4[4] * v5[6]) + (-1 * v0[5] * v1[0] * v2[2] * v3[1] * v4[6] * v5[4]) + (-1 * v0[5] * v1[0] * v2[2] * v3[4] * v4[1] * v5[6]) + (v0[5] * v1[0] * v2[2] * v3[4] * v4[6] * v5[1]) + (v0[5] * v1[0] * v2[2] * v3[6] * v4[1] * v5[4]) + (-1 * v0[5] * v1[0] * v2[2] * v3[6] * v4[4] * v5[1]) + (-1 * v0[5] * v1[0] * v2[4] * v3[1] * v4[2] * v5[6]) + (v0[5] * v1[0] * v2[4] * v3[1] * v4[6] * v5[2]) + (v0[5] * v1[0] * v2[4] * v3[2] * v4[1] * v5[6]) + (-1 * v0[5] * v1[0] * v2[4] * v3[2] * v4[6] * v5[1]) + (-1 * v0[5] * v1[0] * v2[4] * v3[6] * v4[1] * v5[2]) + (v0[5] * v1[0] * v2[4] * v3[6] * v4[2] * v5[1]) + (v0[5] * v1[0] * v2[6] * v3[1] * v4[2] * v5[4]) + (-1 * v0[5] * v1[0] * v2[6] * v3[1] * v4[4] * v5[2]) + (-1 * v0[5] * v1[0] * v2[6] * v3[2] * v4[1] * v5[4]) + (v0[5] * v1[0] * v2[6] * v3[2] * v4[4] * v5[1]) + (v0[5] * v1[0] * v2[6] * v3[4] * v4[1] * v5[2]) + (-1 * v0[5] * v1[0] * v2[6] * v3[4] * v4[2] * v5[1]) + (v0[5] * v1[1] * v2[0] * v3[2] * v4[4] * v5[6]) + (-1 * v0[5] * v1[1] * v2[0] * v3[2] * v4[6] * v5[4]) + (-1 * v0[5] * v1[1] * v2[0] * v3[4] * v4[2] * v5[6]) + (v0[5] * v1[1] * v2[0] * v3[4] * v4[6] * v5[2]) + (v0[5] * v1[1] * v2[0] * v3[6] * v4[2] * v5[4]) + (-1 * v0[5] * v1[1] * v2[0] * v3[6] * v4[4] * v5[2]) + (-1 * v0[5] * v1[1] * v2[2] * v3[0] * v4[4] * v5[6]) + (v0[5] * v1[1] * v2[2] * v3[0] * v4[6] * v5[4]) + (v0[5] * v1[1] * v2[2] * v3[4] * v4[0] * v5[6]) + (-1 * v0[5] * v1[1] * v2[2] * v3[4] * v4[6] * v5[0]) + (-1 * v0[5] * v1[1] * v2[2] * v3[6] * v4[0] * v5[4]) + (v0[5] * v1[1] * v2[2] * v3[6] * v4[4] * v5[0]) + (v0[5] * v1[1] * v2[4] * v3[0] * v4[2] * v5[6]) + (-1 * v0[5] * v1[1] * v2[4] * v3[0] * v4[6] * v5[2]) + (-1 * v0[5] * v1[1] * v2[4] * v3[2] * v4[0] * v5[6]) + (v0[5] * v1[1] * v2[4] * v3[2] * v4[6] * v5[0]) + (v0[5] * v1[1] * v2[4] * v3[6] * v4[0] * v5[2]) + (-1 * v0[5] * v1[1] * v2[4] * v3[6] * v4[2] * v5[0]) + (-1 * v0[5] * v1[1] * v2[6] * v3[0] * v4[2] * v5[4]) + (v0[5] * v1[1] * v2[6] * v3[0] * v4[4] * v5[2]) + (v0[5] * v1[1] * v2[6] * v3[2] * v4[0] * v5[4]) + (-1 * v0[5] * v1[1] * v2[6] * v3[2] * v4[4] * v5[0]) + (-1 * v0[5] * v1[1] * v2[6] * v3[4] * v4[0] * v5[2]) + (v0[5] * v1[1] * v2[6] * v3[4] * v4[2] * v5[0]) + (-1 * v0[5] * v1[2] * v2[0] * v3[1] * v4[4] * v5[6]) + (v0[5] * v1[2] * v2[0] * v3[1] * v4[6] * v5[4]) + (v0[5] * v1[2] * v2[0] * v3[4] * v4[1] * v5[6]) + (-1 * v0[5] * v1[2] * v2[0] * v3[4] * v4[6] * v5[1]) + (-1 * v0[5] * v1[2] * v2[0] * v3[6] * v4[1] * v5[4]) + (v0[5] * v1[2] * v2[0] * v3[6] * v4[4] * v5[1]) + (v0[5] * v1[2] * v2[1] * v3[0] * v4[4] * v5[6]) + (-1 * v0[5] * v1[2] * v2[1] * v3[0] * v4[6] * v5[4]) + (-1 * v0[5] * v1[2] * v2[1] * v3[4] * v4[0] * v5[6]) + (v0[5] * v1[2] * v2[1] * v3[4] * v4[6] * v5[0]) + (v0[5] * v1[2] * v2[1] * v3[6] * v4[0] * v5[4]) + (-1 * v0[5] * v1[2] * v2[1] * v3[6] * v4[4] * v5[0]) + (-1 * v0[5] * v1[2] * v2[4] * v3[0] * v4[1] * v5[6]) + (v0[5] * v1[2] * v2[4] * v3[0] * v4[6] * v5[1]) + (v0[5] * v1[2] * v2[4] * v3[1] * v4[0] * v5[6]) + (-1 * v0[5] * v1[2] * v2[4] * v3[1] * v4[6] * v5[0]) + (-1 * v0[5] * v1[2] * v2[4] * v3[6] * v4[0] * v5[1]) + (v0[5] * v1[2] * v2[4] * v3[6] * v4[1] * v5[0]) + (v0[5] * v1[2] * v2[6] * v3[0] * v4[1] * v5[4]) + (-1 * v0[5] * v1[2] * v2[6] * v3[0] * v4[4] * v5[1]) + (-1 * v0[5] * v1[2] * v2[6] * v3[1] * v4[0] * v5[4]) + (v0[5] * v1[2] * v2[6] * v3[1] * v4[4] * v5[0]) + (v0[5] * v1[2] * v2[6] * v3[4] * v4[0] * v5[1]) + (-1 * v0[5] * v1[2] * v2[6] * v3[4] * v4[1] * v5[0]) + (v0[5] * v1[4] * v2[0] * v3[1] * v4[2] * v5[6]) + (-1 * v0[5] * v1[4] * v2[0] * v3[1] * v4[6] * v5[2]) + (-1 * v0[5] * v1[4] * v2[0] * v3[2] * v4[1] * v5[6]) + (v0[5] * v1[4] * v2[0] * v3[2] * v4[6] * v5[1]) + (v0[5] * v1[4] * v2[0] * v3[6] * v4[1] * v5[2]) + (-1 * v0[5] * v1[4] * v2[0] * v3[6] * v4[2] * v5[1]) + (-1 * v0[5] * v1[4] * v2[1] * v3[0] * v4[2] * v5[6]) + (v0[5] * v1[4] * v2[1] * v3[0] * v4[6] * v5[2]) + (v0[5] * v1[4] * v2[1] * v3[2] * v4[0] * v5[6]) + (-1 * v0[5] * v1[4] * v2[1] * v3[2] * v4[6] * v5[0]) + (-1 * v0[5] * v1[4] * v2[1] * v3[6] * v4[0] * v5[2]) + (v0[5] * v1[4] * v2[1] * v3[6] * v4[2] * v5[0]) + (v0[5] * v1[4] * v2[2] * v3[0] * v4[1] * v5[6]) + (-1 * v0[5] * v1[4] * v2[2] * v3[0] * v4[6] * v5[1]) + (-1 * v0[5] * v1[4] * v2[2] * v3[1] * v4[0] * v5[6]) + (v0[5] * v1[4] * v2[2] * v3[1] * v4[6] * v5[0]) + (v0[5] * v1[4] * v2[2] * v3[6] * v4[0] * v5[1]) + (-1 * v0[5] * v1[4] * v2[2] * v3[6] * v4[1] * v5[0]) + (-1 * v0[5] * v1[4] * v2[6] * v3[0] * v4[1] * v5[2]) + (v0[5] * v1[4] * v2[6] * v3[0] * v4[2] * v5[1]) + (v0[5] * v1[4] * v2[6] * v3[1] * v4[0] * v5[2]) + (-1 * v0[5] * v1[4] * v2[6] * v3[1] * v4[2] * v5[0]) + (-1 * v0[5] * v1[4] * v2[6] * v3[2] * v4[0] * v5[1]) + (v0[5] * v1[4] * v2[6] * v3[2] * v4[1] * v5[0]) + (-1 * v0[5] * v1[6] * v2[0] * v3[1] * v4[2] * v5[4]) + (v0[5] * v1[6] * v2[0] * v3[1] * v4[4] * v5[2]) + (v0[5] * v1[6] * v2[0] * v3[2] * v4[1] * v5[4]) + (-1 * v0[5] * v1[6] * v2[0] * v3[2] * v4[4] * v5[1]) + (-1 * v0[5] * v1[6] * v2[0] * v3[4] * v4[1] * v5[2]) + (v0[5] * v1[6] * v2[0] * v3[4] * v4[2] * v5[1]) + (v0[5] * v1[6] * v2[1] * v3[0] * v4[2] * v5[4]) + (-1 * v0[5] * v1[6] * v2[1] * v3[0] * v4[4] * v5[2]) + (-1 * v0[5] * v1[6] * v2[1] * v3[2] * v4[0] * v5[4]) + (v0[5] * v1[6] * v2[1] * v3[2] * v4[4] * v5[0]) + (v0[5] * v1[6] * v2[1] * v3[4] * v4[0] * v5[2]) + (-1 * v0[5] * v1[6] * v2[1] * v3[4] * v4[2] * v5[0]) + (-1 * v0[5] * v1[6] * v2[2] * v3[0] * v4[1] * v5[4]) + (v0[5] * v1[6] * v2[2] * v3[0] * v4[4] * v5[1]) + (v0[5] * v1[6] * v2[2] * v3[1] * v4[0] * v5[4]) + (-1 * v0[5] * v1[6] * v2[2] * v3[1] * v4[4] * v5[0]) + (-1 * v0[5] * v1[6] * v2[2] * v3[4] * v4[0] * v5[1]) + (v0[5] * v1[6] * v2[2] * v3[4] * v4[1] * v5[0]) + (v0[5] * v1[6] * v2[4] * v3[0] * v4[1] * v5[2]) + (-1 * v0[5] * v1[6] * v2[4] * v3[0] * v4[2] * v5[1]) + (-1 * v0[5] * v1[6] * v2[4] * v3[1] * v4[0] * v5[2]) + (v0[5] * v1[6] * v2[4] * v3[1] * v4[2] * v5[0]) + (v0[5] * v1[6] * v2[4] * v3[2] * v4[0] * v5[1]) + (-1 * v0[5] * v1[6] * v2[4] * v3[2] * v4[1] * v5[0]) + (v0[6] * v1[0] * v2[1] * v3[2] * v4[4] * v5[5]) + (-1 * v0[6] * v1[0] * v2[1] * v3[2] * v4[5] * v5[4]) + (-1 * v0[6] * v1[0] * v2[1] * v3[4] * v4[2] * v5[5]) + (v0[6] * v1[0] * v2[1] * v3[4] * v4[5] * v5[2]) + (v0[6] * v1[0] * v2[1] * v3[5] * v4[2] * v5[4]) + (-1 * v0[6] * v1[0] * v2[1] * v3[5] * v4[4] * v5[2]) + (-1 * v0[6] * v1[0] * v2[2] * v3[1] * v4[4] * v5[5]) + (v0[6] * v1[0] * v2[2] * v3[1] * v4[5] * v5[4]) + (v0[6] * v1[0] * v2[2] * v3[4] * v4[1] * v5[5]) + (-1 * v0[6] * v1[0] * v2[2] * v3[4] * v4[5] * v5[1]) + (-1 * v0[6] * v1[0] * v2[2] * v3[5] * v4[1] * v5[4]) + (v0[6] * v1[0] * v2[2] * v3[5] * v4[4] * v5[1]) + (v0[6] * v1[0] * v2[4] * v3[1] * v4[2] * v5[5]) + (-1 * v0[6] * v1[0] * v2[4] * v3[1] * v4[5] * v5[2]) + (-1 * v0[6] * v1[0] * v2[4] * v3[2] * v4[1] * v5[5]) + (v0[6] * v1[0] * v2[4] * v3[2] * v4[5] * v5[1]) + (v0[6] * v1[0] * v2[4] * v3[5] * v4[1] * v5[2]) + (-1 * v0[6] * v1[0] * v2[4] * v3[5] * v4[2] * v5[1]) + (-1 * v0[6] * v1[0] * v2[5] * v3[1] * v4[2] * v5[4]) + (v0[6] * v1[0] * v2[5] * v3[1] * v4[4] * v5[2]) + (v0[6] * v1[0] * v2[5] * v3[2] * v4[1] * v5[4]) + (-1 * v0[6] * v1[0] * v2[5] * v3[2] * v4[4] * v5[1]) + (-1 * v0[6] * v1[0] * v2[5] * v3[4] * v4[1] * v5[2]) + (v0[6] * v1[0] * v2[5] * v3[4] * v4[2] * v5[1]) + (-1 * v0[6] * v1[1] * v2[0] * v3[2] * v4[4] * v5[5]) + (v0[6] * v1[1] * v2[0] * v3[2] * v4[5] * v5[4]) + (v0[6] * v1[1] * v2[0] * v3[4] * v4[2] * v5[5]) + (-1 * v0[6] * v1[1] * v2[0] * v3[4] * v4[5] * v5[2]) + (-1 * v0[6] * v1[1] * v2[0] * v3[5] * v4[2] * v5[4]) + (v0[6] * v1[1] * v2[0] * v3[5] * v4[4] * v5[2]) + (v0[6] * v1[1] * v2[2] * v3[0] * v4[4] * v5[5]) + (-1 * v0[6] * v1[1] * v2[2] * v3[0] * v4[5] * v5[4]) + (-1 * v0[6] * v1[1] * v2[2] * v3[4] * v4[0] * v5[5]) + (v0[6] * v1[1] * v2[2] * v3[4] * v4[5] * v5[0]) + (v0[6] * v1[1] * v2[2] * v3[5] * v4[0] * v5[4]) + (-1 * v0[6] * v1[1] * v2[2] * v3[5] * v4[4] * v5[0]) + (-1 * v0[6] * v1[1] * v2[4] * v3[0] * v4[2] * v5[5]) + (v0[6] * v1[1] * v2[4] * v3[0] * v4[5] * v5[2]) + (v0[6] * v1[1] * v2[4] * v3[2] * v4[0] * v5[5]) + (-1 * v0[6] * v1[1] * v2[4] * v3[2] * v4[5] * v5[0]) + (-1 * v0[6] * v1[1] * v2[4] * v3[5] * v4[0] * v5[2]) + (v0[6] * v1[1] * v2[4] * v3[5] * v4[2] * v5[0]) + (v0[6] * v1[1] * v2[5] * v3[0] * v4[2] * v5[4]) + (-1 * v0[6] * v1[1] * v2[5] * v3[0] * v4[4] * v5[2]) + (-1 * v0[6] * v1[1] * v2[5] * v3[2] * v4[0] * v5[4]) + (v0[6] * v1[1] * v2[5] * v3[2] * v4[4] * v5[0]) + (v0[6] * v1[1] * v2[5] * v3[4] * v4[0] * v5[2]) + (-1 * v0[6] * v1[1] * v2[5] * v3[4] * v4[2] * v5[0]) + (v0[6] * v1[2] * v2[0] * v3[1] * v4[4] * v5[5]) + (-1 * v0[6] * v1[2] * v2[0] * v3[1] * v4[5] * v5[4]) + (-1 * v0[6] * v1[2] * v2[0] * v3[4] * v4[1] * v5[5]) + (v0[6] * v1[2] * v2[0] * v3[4] * v4[5] * v5[1]) + (v0[6] * v1[2] * v2[0] * v3[5] * v4[1] * v5[4]) + (-1 * v0[6] * v1[2] * v2[0] * v3[5] * v4[4] * v5[1]) + (-1 * v0[6] * v1[2] * v2[1] * v3[0] * v4[4] * v5[5]) + (v0[6] * v1[2] * v2[1] * v3[0] * v4[5] * v5[4]) + (v0[6] * v1[2] * v2[1] * v3[4] * v4[0] * v5[5]) + (-1 * v0[6] * v1[2] * v2[1] * v3[4] * v4[5] * v5[0]) + (-1 * v0[6] * v1[2] * v2[1] * v3[5] * v4[0] * v5[4]) + (v0[6] * v1[2] * v2[1] * v3[5] * v4[4] * v5[0]) + (v0[6] * v1[2] * v2[4] * v3[0] * v4[1] * v5[5]) + (-1 * v0[6] * v1[2] * v2[4] * v3[0] * v4[5] * v5[1]) + (-1 * v0[6] * v1[2] * v2[4] * v3[1] * v4[0] * v5[5]) + (v0[6] * v1[2] * v2[4] * v3[1] * v4[5] * v5[0]) + (v0[6] * v1[2] * v2[4] * v3[5] * v4[0] * v5[1]) + (-1 * v0[6] * v1[2] * v2[4] * v3[5] * v4[1] * v5[0]) + (-1 * v0[6] * v1[2] * v2[5] * v3[0] * v4[1] * v5[4]) + (v0[6] * v1[2] * v2[5] * v3[0] * v4[4] * v5[1]) + (v0[6] * v1[2] * v2[5] * v3[1] * v4[0] * v5[4]) + (-1 * v0[6] * v1[2] * v2[5] * v3[1] * v4[4] * v5[0]) + (-1 * v0[6] * v1[2] * v2[5] * v3[4] * v4[0] * v5[1]) + (v0[6] * v1[2] * v2[5] * v3[4] * v4[1] * v5[0]) + (-1 * v0[6] * v1[4] * v2[0] * v3[1] * v4[2] * v5[5]) + (v0[6] * v1[4] * v2[0] * v3[1] * v4[5] * v5[2]) + (v0[6] * v1[4] * v2[0] * v3[2] * v4[1] * v5[5]) + (-1 * v0[6] * v1[4] * v2[0] * v3[2] * v4[5] * v5[1]) + (-1 * v0[6] * v1[4] * v2[0] * v3[5] * v4[1] * v5[2]) + (v0[6] * v1[4] * v2[0] * v3[5] * v4[2] * v5[1]) + (v0[6] * v1[4] * v2[1] * v3[0] * v4[2] * v5[5]) + (-1 * v0[6] * v1[4] * v2[1] * v3[0] * v4[5] * v5[2]) + (-1 * v0[6] * v1[4] * v2[1] * v3[2] * v4[0] * v5[5]) + (v0[6] * v1[4] * v2[1] * v3[2] * v4[5] * v5[0]) + (v0[6] * v1[4] * v2[1] * v3[5] * v4[0] * v5[2]) + (-1 * v0[6] * v1[4] * v2[1] * v3[5] * v4[2] * v5[0]) + (-1 * v0[6] * v1[4] * v2[2] * v3[0] * v4[1] * v5[5]) + (v0[6] * v1[4] * v2[2] * v3[0] * v4[5] * v5[1]) + (v0[6] * v1[4] * v2[2] * v3[1] * v4[0] * v5[5]) + (-1 * v0[6] * v1[4] * v2[2] * v3[1] * v4[5] * v5[0]) + (-1 * v0[6] * v1[4] * v2[2] * v3[5] * v4[0] * v5[1]) + (v0[6] * v1[4] * v2[2] * v3[5] * v4[1] * v5[0]) + (v0[6] * v1[4] * v2[5] * v3[0] * v4[1] * v5[2]) + (-1 * v0[6] * v1[4] * v2[5] * v3[0] * v4[2] * v5[1]) + (-1 * v0[6] * v1[4] * v2[5] * v3[1] * v4[0] * v5[2]) + (v0[6] * v1[4] * v2[5] * v3[1] * v4[2] * v5[0]) + (v0[6] * v1[4] * v2[5] * v3[2] * v4[0] * v5[1]) + (-1 * v0[6] * v1[4] * v2[5] * v3[2] * v4[1] * v5[0]) + (v0[6] * v1[5] * v2[0] * v3[1] * v4[2] * v5[4]) + (-1 * v0[6] * v1[5] * v2[0] * v3[1] * v4[4] * v5[2]) + (-1 * v0[6] * v1[5] * v2[0] * v3[2] * v4[1] * v5[4]) + (v0[6] * v1[5] * v2[0] * v3[2] * v4[4] * v5[1]) + (v0[6] * v1[5] * v2[0] * v3[4] * v4[1] * v5[2]) + (-1 * v0[6] * v1[5] * v2[0] * v3[4] * v4[2] * v5[1]) + (-1 * v0[6] * v1[5] * v2[1] * v3[0] * v4[2] * v5[4]) + (v0[6] * v1[5] * v2[1] * v3[0] * v4[4] * v5[2]) + (v0[6] * v1[5] * v2[1] * v3[2] * v4[0] * v5[4]) + (-1 * v0[6] * v1[5] * v2[1] * v3[2] * v4[4] * v5[0]) + (-1 * v0[6] * v1[5] * v2[1] * v3[4] * v4[0] * v5[2]) + (v0[6] * v1[5] * v2[1] * v3[4] * v4[2] * v5[0]) + (v0[6] * v1[5] * v2[2] * v3[0] * v4[1] * v5[4]) + (-1 * v0[6] * v1[5] * v2[2] * v3[0] * v4[4] * v5[1]) + (-1 * v0[6] * v1[5] * v2[2] * v3[1] * v4[0] * v5[4]) + (v0[6] * v1[5] * v2[2] * v3[1] * v4[4] * v5[0]) + (v0[6] * v1[5] * v2[2] * v3[4] * v4[0] * v5[1]) + (-1 * v0[6] * v1[5] * v2[2] * v3[4] * v4[1] * v5[0]) + (-1 * v0[6] * v1[5] * v2[4] * v3[0] * v4[1] * v5[2]) + (v0[6] * v1[5] * v2[4] * v3[0] * v4[2] * v5[1]) + (v0[6] * v1[5] * v2[4] * v3[1] * v4[0] * v5[2]) + (-1 * v0[6] * v1[5] * v2[4] * v3[1] * v4[2] * v5[0]) + (-1 * v0[6] * v1[5] * v2[4] * v3[2] * v4[0] * v5[1]) + (v0[6] * v1[5] * v2[4] * v3[2] * v4[1] * v5[0]);
r0[4] = (v0[0] * v1[1] * v2[2] * v3[3] * v4[5] * v5[6]) + (-1 * v0[0] * v1[1] * v2[2] * v3[3] * v4[6] * v5[5]) + (-1 * v0[0] * v1[1] * v2[2] * v3[5] * v4[3] * v5[6]) + (v0[0] * v1[1] * v2[2] * v3[5] * v4[6] * v5[3]) + (v0[0] * v1[1] * v2[2] * v3[6] * v4[3] * v5[5]) + (-1 * v0[0] * v1[1] * v2[2] * v3[6] * v4[5] * v5[3]) + (-1 * v0[0] * v1[1] * v2[3] * v3[2] * v4[5] * v5[6]) + (v0[0] * v1[1] * v2[3] * v3[2] * v4[6] * v5[5]) + (v0[0] * v1[1] * v2[3] * v3[5] * v4[2] * v5[6]) + (-1 * v0[0] * v1[1] * v2[3] * v3[5] * v4[6] * v5[2]) + (-1 * v0[0] * v1[1] * v2[3] * v3[6] * v4[2] * v5[5]) + (v0[0] * v1[1] * v2[3] * v3[6] * v4[5] * v5[2]) + (v0[0] * v1[1] * v2[5] * v3[2] * v4[3] * v5[6]) + (-1 * v0[0] * v1[1] * v2[5] * v3[2] * v4[6] * v5[3]) + (-1 * v0[0] * v1[1] * v2[5] * v3[3] * v4[2] * v5[6]) + (v0[0] * v1[1] * v2[5] * v3[3] * v4[6] * v5[2]) + (v0[0] * v1[1] * v2[5] * v3[6] * v4[2] * v5[3]) + (-1 * v0[0] * v1[1] * v2[5] * v3[6] * v4[3] * v5[2]) + (-1 * v0[0] * v1[1] * v2[6] * v3[2] * v4[3] * v5[5]) + (v0[0] * v1[1] * v2[6] * v3[2] * v4[5] * v5[3]) + (v0[0] * v1[1] * v2[6] * v3[3] * v4[2] * v5[5]) + (-1 * v0[0] * v1[1] * v2[6] * v3[3] * v4[5] * v5[2]) + (-1 * v0[0] * v1[1] * v2[6] * v3[5] * v4[2] * v5[3]) + (v0[0] * v1[1] * v2[6] * v3[5] * v4[3] * v5[2]) + (-1 * v0[0] * v1[2] * v2[1] * v3[3] * v4[5] * v5[6]) + (v0[0] * v1[2] * v2[1] * v3[3] * v4[6] * v5[5]) + (v0[0] * v1[2] * v2[1] * v3[5] * v4[3] * v5[6]) + (-1 * v0[0] * v1[2] * v2[1] * v3[5] * v4[6] * v5[3]) + (-1 * v0[0] * v1[2] * v2[1] * v3[6] * v4[3] * v5[5]) + (v0[0] * v1[2] * v2[1] * v3[6] * v4[5] * v5[3]) + (v0[0] * v1[2] * v2[3] * v3[1] * v4[5] * v5[6]) + (-1 * v0[0] * v1[2] * v2[3] * v3[1] * v4[6] * v5[5]) + (-1 * v0[0] * v1[2] * v2[3] * v3[5] * v4[1] * v5[6]) + (v0[0] * v1[2] * v2[3] * v3[5] * v4[6] * v5[1]) + (v0[0] * v1[2] * v2[3] * v3[6] * v4[1] * v5[5]) + (-1 * v0[0] * v1[2] * v2[3] * v3[6] * v4[5] * v5[1]) + (-1 * v0[0] * v1[2] * v2[5] * v3[1] * v4[3] * v5[6]) + (v0[0] * v1[2] * v2[5] * v3[1] * v4[6] * v5[3]) + (v0[0] * v1[2] * v2[5] * v3[3] * v4[1] * v5[6]) + (-1 * v0[0] * v1[2] * v2[5] * v3[3] * v4[6] * v5[1]) + (-1 * v0[0] * v1[2] * v2[5] * v3[6] * v4[1] * v5[3]) + (v0[0] * v1[2] * v2[5] * v3[6] * v4[3] * v5[1]) + (v0[0] * v1[2] * v2[6] * v3[1] * v4[3] * v5[5]) + (-1 * v0[0] * v1[2] * v2[6] * v3[1] * v4[5] * v5[3]) + (-1 * v0[0] * v1[2] * v2[6] * v3[3] * v4[1] * v5[5]) + (v0[0] * v1[2] * v2[6] * v3[3] * v4[5] * v5[1]) + (v0[0] * v1[2] * v2[6] * v3[5] * v4[1] * v5[3]) + (-1 * v0[0] * v1[2] * v2[6] * v3[5] * v4[3] * v5[1]) + (v0[0] * v1[3] * v2[1] * v3[2] * v4[5] * v5[6]) + (-1 * v0[0] * v1[3] * v2[1] * v3[2] * v4[6] * v5[5]) + (-1 * v0[0] * v1[3] * v2[1] * v3[5] * v4[2] * v5[6]) + (v0[0] * v1[3] * v2[1] * v3[5] * v4[6] * v5[2]) + (v0[0] * v1[3] * v2[1] * v3[6] * v4[2] * v5[5]) + (-1 * v0[0] * v1[3] * v2[1] * v3[6] * v4[5] * v5[2]) + (-1 * v0[0] * v1[3] * v2[2] * v3[1] * v4[5] * v5[6]) + (v0[0] * v1[3] * v2[2] * v3[1] * v4[6] * v5[5]) + (v0[0] * v1[3] * v2[2] * v3[5] * v4[1] * v5[6]) + (-1 * v0[0] * v1[3] * v2[2] * v3[5] * v4[6] * v5[1]) + (-1 * v0[0] * v1[3] * v2[2] * v3[6] * v4[1] * v5[5]) + (v0[0] * v1[3] * v2[2] * v3[6] * v4[5] * v5[1]) + (v0[0] * v1[3] * v2[5] * v3[1] * v4[2] * v5[6]) + (-1 * v0[0] * v1[3] * v2[5] * v3[1] * v4[6] * v5[2]) + (-1 * v0[0] * v1[3] * v2[5] * v3[2] * v4[1] * v5[6]) + (v0[0] * v1[3] * v2[5] * v3[2] * v4[6] * v5[1]) + (v0[0] * v1[3] * v2[5] * v3[6] * v4[1] * v5[2]) + (-1 * v0[0] * v1[3] * v2[5] * v3[6] * v4[2] * v5[1]) + (-1 * v0[0] * v1[3] * v2[6] * v3[1] * v4[2] * v5[5]) + (v0[0] * v1[3] * v2[6] * v3[1] * v4[5] * v5[2]) + (v0[0] * v1[3] * v2[6] * v3[2] * v4[1] * v5[5]) + (-1 * v0[0] * v1[3] * v2[6] * v3[2] * v4[5] * v5[1]) + (-1 * v0[0] * v1[3] * v2[6] * v3[5] * v4[1] * v5[2]) + (v0[0] * v1[3] * v2[6] * v3[5] * v4[2] * v5[1]) + (-1 * v0[0] * v1[5] * v2[1] * v3[2] * v4[3] * v5[6]) + (v0[0] * v1[5] * v2[1] * v3[2] * v4[6] * v5[3]) + (v0[0] * v1[5] * v2[1] * v3[3] * v4[2] * v5[6]) + (-1 * v0[0] * v1[5] * v2[1] * v3[3] * v4[6] * v5[2]) + (-1 * v0[0] * v1[5] * v2[1] * v3[6] * v4[2] * v5[3]) + (v0[0] * v1[5] * v2[1] * v3[6] * v4[3] * v5[2]) + (v0[0] * v1[5] * v2[2] * v3[1] * v4[3] * v5[6]) + (-1 * v0[0] * v1[5] * v2[2] * v3[1] * v4[6] * v5[3]) + (-1 * v0[0] * v1[5] * v2[2] * v3[3] * v4[1] * v5[6]) + (v0[0] * v1[5] * v2[2] * v3[3] * v4[6] * v5[1]) + (v0[0] * v1[5] * v2[2] * v3[6] * v4[1] * v5[3]) + (-1 * v0[0] * v1[5] * v2[2] * v3[6] * v4[3] * v5[1]) + (-1 * v0[0] * v1[5] * v2[3] * v3[1] * v4[2] * v5[6]) + (v0[0] * v1[5] * v2[3] * v3[1] * v4[6] * v5[2]) + (v0[0] * v1[5] * v2[3] * v3[2] * v4[1] * v5[6]) + (-1 * v0[0] * v1[5] * v2[3] * v3[2] * v4[6] * v5[1]) + (-1 * v0[0] * v1[5] * v2[3] * v3[6] * v4[1] * v5[2]) + (v0[0] * v1[5] * v2[3] * v3[6] * v4[2] * v5[1]) + (v0[0] * v1[5] * v2[6] * v3[1] * v4[2] * v5[3]) + (-1 * v0[0] * v1[5] * v2[6] * v3[1] * v4[3] * v5[2]) + (-1 * v0[0] * v1[5] * v2[6] * v3[2] * v4[1] * v5[3]) + (v0[0] * v1[5] * v2[6] * v3[2] * v4[3] * v5[1]) + (v0[0] * v1[5] * v2[6] * v3[3] * v4[1] * v5[2]) + (-1 * v0[0] * v1[5] * v2[6] * v3[3] * v4[2] * v5[1]) + (v0[0] * v1[6] * v2[1] * v3[2] * v4[3] * v5[5]) + (-1 * v0[0] * v1[6] * v2[1] * v3[2] * v4[5] * v5[3]) + (-1 * v0[0] * v1[6] * v2[1] * v3[3] * v4[2] * v5[5]) + (v0[0] * v1[6] * v2[1] * v3[3] * v4[5] * v5[2]) + (v0[0] * v1[6] * v2[1] * v3[5] * v4[2] * v5[3]) + (-1 * v0[0] * v1[6] * v2[1] * v3[5] * v4[3] * v5[2]) + (-1 * v0[0] * v1[6] * v2[2] * v3[1] * v4[3] * v5[5]) + (v0[0] * v1[6] * v2[2] * v3[1] * v4[5] * v5[3]) + (v0[0] * v1[6] * v2[2] * v3[3] * v4[1] * v5[5]) + (-1 * v0[0] * v1[6] * v2[2] * v3[3] * v4[5] * v5[1]) + (-1 * v0[0] * v1[6] * v2[2] * v3[5] * v4[1] * v5[3]) + (v0[0] * v1[6] * v2[2] * v3[5] * v4[3] * v5[1]) + (v0[0] * v1[6] * v2[3] * v3[1] * v4[2] * v5[5]) + (-1 * v0[0] * v1[6] * v2[3] * v3[1] * v4[5] * v5[2]) + (-1 * v0[0] * v1[6] * v2[3] * v3[2] * v4[1] * v5[5]) + (v0[0] * v1[6] * v2[3] * v3[2] * v4[5] * v5[1]) + (v0[0] * v1[6] * v2[3] * v3[5] * v4[1] * v5[2]) + (-1 * v0[0] * v1[6] * v2[3] * v3[5] * v4[2] * v5[1]) + (-1 * v0[0] * v1[6] * v2[5] * v3[1] * v4[2] * v5[3]) + (v0[0] * v1[6] * v2[5] * v3[1] * v4[3] * v5[2]) + (v0[0] * v1[6] * v2[5] * v3[2] * v4[1] * v5[3]) + (-1 * v0[0] * v1[6] * v2[5] * v3[2] * v4[3] * v5[1]) + (-1 * v0[0] * v1[6] * v2[5] * v3[3] * v4[1] * v5[2]) + (v0[0] * v1[6] * v2[5] * v3[3] * v4[2] * v5[1]) + (-1 * v0[1] * v1[0] * v2[2] * v3[3] * v4[5] * v5[6]) + (v0[1] * v1[0] * v2[2] * v3[3] * v4[6] * v5[5]) + (v0[1] * v1[0] * v2[2] * v3[5] * v4[3] * v5[6]) + (-1 * v0[1] * v1[0] * v2[2] * v3[5] * v4[6] * v5[3]) + (-1 * v0[1] * v1[0] * v2[2] * v3[6] * v4[3] * v5[5]) + (v0[1] * v1[0] * v2[2] * v3[6] * v4[5] * v5[3]) + (v0[1] * v1[0] * v2[3] * v3[2] * v4[5] * v5[6]) + (-1 * v0[1] * v1[0] * v2[3] * v3[2] * v4[6] * v5[5]) + (-1 * v0[1] * v1[0] * v2[3] * v3[5] * v4[2] * v5[6]) + (v0[1] * v1[0] * v2[3] * v3[5] * v4[6] * v5[2]) + (v0[1] * v1[0] * v2[3] * v3[6] * v4[2] * v5[5]) + (-1 * v0[1] * v1[0] * v2[3] * v3[6] * v4[5] * v5[2]) + (-1 * v0[1] * v1[0] * v2[5] * v3[2] * v4[3] * v5[6]) + (v0[1] * v1[0] * v2[5] * v3[2] * v4[6] * v5[3]) + (v0[1] * v1[0] * v2[5] * v3[3] * v4[2] * v5[6]) + (-1 * v0[1] * v1[0] * v2[5] * v3[3] * v4[6] * v5[2]) + (-1 * v0[1] * v1[0] * v2[5] * v3[6] * v4[2] * v5[3]) + (v0[1] * v1[0] * v2[5] * v3[6] * v4[3] * v5[2]) + (v0[1] * v1[0] * v2[6] * v3[2] * v4[3] * v5[5]) + (-1 * v0[1] * v1[0] * v2[6] * v3[2] * v4[5] * v5[3]) + (-1 * v0[1] * v1[0] * v2[6] * v3[3] * v4[2] * v5[5]) + (v0[1] * v1[0] * v2[6] * v3[3] * v4[5] * v5[2]) + (v0[1] * v1[0] * v2[6] * v3[5] * v4[2] * v5[3]) + (-1 * v0[1] * v1[0] * v2[6] * v3[5] * v4[3] * v5[2]) + (v0[1] * v1[2] * v2[0] * v3[3] * v4[5] * v5[6]) + (-1 * v0[1] * v1[2] * v2[0] * v3[3] * v4[6] * v5[5]) + (-1 * v0[1] * v1[2] * v2[0] * v3[5] * v4[3] * v5[6]) + (v0[1] * v1[2] * v2[0] * v3[5] * v4[6] * v5[3]) + (v0[1] * v1[2] * v2[0] * v3[6] * v4[3] * v5[5]) + (-1 * v0[1] * v1[2] * v2[0] * v3[6] * v4[5] * v5[3]) + (-1 * v0[1] * v1[2] * v2[3] * v3[0] * v4[5] * v5[6]) + (v0[1] * v1[2] * v2[3] * v3[0] * v4[6] * v5[5]) + (v0[1] * v1[2] * v2[3] * v3[5] * v4[0] * v5[6]) + (-1 * v0[1] * v1[2] * v2[3] * v3[5] * v4[6] * v5[0]) + (-1 * v0[1] * v1[2] * v2[3] * v3[6] * v4[0] * v5[5]) + (v0[1] * v1[2] * v2[3] * v3[6] * v4[5] * v5[0]) + (v0[1] * v1[2] * v2[5] * v3[0] * v4[3] * v5[6]) + (-1 * v0[1] * v1[2] * v2[5] * v3[0] * v4[6] * v5[3]) + (-1 * v0[1] * v1[2] * v2[5] * v3[3] * v4[0] * v5[6]) + (v0[1] * v1[2] * v2[5] * v3[3] * v4[6] * v5[0]) + (v0[1] * v1[2] * v2[5] * v3[6] * v4[0] * v5[3]) + (-1 * v0[1] * v1[2] * v2[5] * v3[6] * v4[3] * v5[0]) + (-1 * v0[1] * v1[2] * v2[6] * v3[0] * v4[3] * v5[5]) + (v0[1] * v1[2] * v2[6] * v3[0] * v4[5] * v5[3]) + (v0[1] * v1[2] * v2[6] * v3[3] * v4[0] * v5[5]) + (-1 * v0[1] * v1[2] * v2[6] * v3[3] * v4[5] * v5[0]) + (-1 * v0[1] * v1[2] * v2[6] * v3[5] * v4[0] * v5[3]) + (v0[1] * v1[2] * v2[6] * v3[5] * v4[3] * v5[0]) + (-1 * v0[1] * v1[3] * v2[0] * v3[2] * v4[5] * v5[6]) + (v0[1] * v1[3] * v2[0] * v3[2] * v4[6] * v5[5]) + (v0[1] * v1[3] * v2[0] * v3[5] * v4[2] * v5[6]) + (-1 * v0[1] * v1[3] * v2[0] * v3[5] * v4[6] * v5[2]) + (-1 * v0[1] * v1[3] * v2[0] * v3[6] * v4[2] * v5[5]) + (v0[1] * v1[3] * v2[0] * v3[6] * v4[5] * v5[2]) + (v0[1] * v1[3] * v2[2] * v3[0] * v4[5] * v5[6]) + (-1 * v0[1] * v1[3] * v2[2] * v3[0] * v4[6] * v5[5]) + (-1 * v0[1] * v1[3] * v2[2] * v3[5] * v4[0] * v5[6]) + (v0[1] * v1[3] * v2[2] * v3[5] * v4[6] * v5[0]) + (v0[1] * v1[3] * v2[2] * v3[6] * v4[0] * v5[5]) + (-1 * v0[1] * v1[3] * v2[2] * v3[6] * v4[5] * v5[0]) + (-1 * v0[1] * v1[3] * v2[5] * v3[0] * v4[2] * v5[6]) + (v0[1] * v1[3] * v2[5] * v3[0] * v4[6] * v5[2]) + (v0[1] * v1[3] * v2[5] * v3[2] * v4[0] * v5[6]) + (-1 * v0[1] * v1[3] * v2[5] * v3[2] * v4[6] * v5[0]) + (-1 * v0[1] * v1[3] * v2[5] * v3[6] * v4[0] * v5[2]) + (v0[1] * v1[3] * v2[5] * v3[6] * v4[2] * v5[0]) + (v0[1] * v1[3] * v2[6] * v3[0] * v4[2] * v5[5]) + (-1 * v0[1] * v1[3] * v2[6] * v3[0] * v4[5] * v5[2]) + (-1 * v0[1] * v1[3] * v2[6] * v3[2] * v4[0] * v5[5]) + (v0[1] * v1[3] * v2[6] * v3[2] * v4[5] * v5[0]) + (v0[1] * v1[3] * v2[6] * v3[5] * v4[0] * v5[2]) + (-1 * v0[1] * v1[3] * v2[6] * v3[5] * v4[2] * v5[0]) + (v0[1] * v1[5] * v2[0] * v3[2] * v4[3] * v5[6]) + (-1 * v0[1] * v1[5] * v2[0] * v3[2] * v4[6] * v5[3]) + (-1 * v0[1] * v1[5] * v2[0] * v3[3] * v4[2] * v5[6]) + (v0[1] * v1[5] * v2[0] * v3[3] * v4[6] * v5[2]) + (v0[1] * v1[5] * v2[0] * v3[6] * v4[2] * v5[3]) + (-1 * v0[1] * v1[5] * v2[0] * v3[6] * v4[3] * v5[2]) + (-1 * v0[1] * v1[5] * v2[2] * v3[0] * v4[3] * v5[6]) + (v0[1] * v1[5] * v2[2] * v3[0] * v4[6] * v5[3]) + (v0[1] * v1[5] * v2[2] * v3[3] * v4[0] * v5[6]) + (-1 * v0[1] * v1[5] * v2[2] * v3[3] * v4[6] * v5[0]) + (-1 * v0[1] * v1[5] * v2[2] * v3[6] * v4[0] * v5[3]) + (v0[1] * v1[5] * v2[2] * v3[6] * v4[3] * v5[0]) + (v0[1] * v1[5] * v2[3] * v3[0] * v4[2] * v5[6]) + (-1 * v0[1] * v1[5] * v2[3] * v3[0] * v4[6] * v5[2]) + (-1 * v0[1] * v1[5] * v2[3] * v3[2] * v4[0] * v5[6]) + (v0[1] * v1[5] * v2[3] * v3[2] * v4[6] * v5[0]) + (v0[1] * v1[5] * v2[3] * v3[6] * v4[0] * v5[2]) + (-1 * v0[1] * v1[5] * v2[3] * v3[6] * v4[2] * v5[0]) + (-1 * v0[1] * v1[5] * v2[6] * v3[0] * v4[2] * v5[3]) + (v0[1] * v1[5] * v2[6] * v3[0] * v4[3] * v5[2]) + (v0[1] * v1[5] * v2[6] * v3[2] * v4[0] * v5[3]) + (-1 * v0[1] * v1[5] * v2[6] * v3[2] * v4[3] * v5[0]) + (-1 * v0[1] * v1[5] * v2[6] * v3[3] * v4[0] * v5[2]) + (v0[1] * v1[5] * v2[6] * v3[3] * v4[2] * v5[0]) + (-1 * v0[1] * v1[6] * v2[0] * v3[2] * v4[3] * v5[5]) + (v0[1] * v1[6] * v2[0] * v3[2] * v4[5] * v5[3]) + (v0[1] * v1[6] * v2[0] * v3[3] * v4[2] * v5[5]) + (-1 * v0[1] * v1[6] * v2[0] * v3[3] * v4[5] * v5[2]) + (-1 * v0[1] * v1[6] * v2[0] * v3[5] * v4[2] * v5[3]) + (v0[1] * v1[6] * v2[0] * v3[5] * v4[3] * v5[2]) + (v0[1] * v1[6] * v2[2] * v3[0] * v4[3] * v5[5]) + (-1 * v0[1] * v1[6] * v2[2] * v3[0] * v4[5] * v5[3]) + (-1 * v0[1] * v1[6] * v2[2] * v3[3] * v4[0] * v5[5]) + (v0[1] * v1[6] * v2[2] * v3[3] * v4[5] * v5[0]) + (v0[1] * v1[6] * v2[2] * v3[5] * v4[0] * v5[3]) + (-1 * v0[1] * v1[6] * v2[2] * v3[5] * v4[3] * v5[0]) + (-1 * v0[1] * v1[6] * v2[3] * v3[0] * v4[2] * v5[5]) + (v0[1] * v1[6] * v2[3] * v3[0] * v4[5] * v5[2]) + (v0[1] * v1[6] * v2[3] * v3[2] * v4[0] * v5[5]) + (-1 * v0[1] * v1[6] * v2[3] * v3[2] * v4[5] * v5[0]) + (-1 * v0[1] * v1[6] * v2[3] * v3[5] * v4[0] * v5[2]) + (v0[1] * v1[6] * v2[3] * v3[5] * v4[2] * v5[0]) + (v0[1] * v1[6] * v2[5] * v3[0] * v4[2] * v5[3]) + (-1 * v0[1] * v1[6] * v2[5] * v3[0] * v4[3] * v5[2]) + (-1 * v0[1] * v1[6] * v2[5] * v3[2] * v4[0] * v5[3]) + (v0[1] * v1[6] * v2[5] * v3[2] * v4[3] * v5[0]) + (v0[1] * v1[6] * v2[5] * v3[3] * v4[0] * v5[2]) + (-1 * v0[1] * v1[6] * v2[5] * v3[3] * v4[2] * v5[0]) + (v0[2] * v1[0] * v2[1] * v3[3] * v4[5] * v5[6]) + (-1 * v0[2] * v1[0] * v2[1] * v3[3] * v4[6] * v5[5]) + (-1 * v0[2] * v1[0] * v2[1] * v3[5] * v4[3] * v5[6]) + (v0[2] * v1[0] * v2[1] * v3[5] * v4[6] * v5[3]) + (v0[2] * v1[0] * v2[1] * v3[6] * v4[3] * v5[5]) + (-1 * v0[2] * v1[0] * v2[1] * v3[6] * v4[5] * v5[3]) + (-1 * v0[2] * v1[0] * v2[3] * v3[1] * v4[5] * v5[6]) + (v0[2] * v1[0] * v2[3] * v3[1] * v4[6] * v5[5]) + (v0[2] * v1[0] * v2[3] * v3[5] * v4[1] * v5[6]) + (-1 * v0[2] * v1[0] * v2[3] * v3[5] * v4[6] * v5[1]) + (-1 * v0[2] * v1[0] * v2[3] * v3[6] * v4[1] * v5[5]) + (v0[2] * v1[0] * v2[3] * v3[6] * v4[5] * v5[1]) + (v0[2] * v1[0] * v2[5] * v3[1] * v4[3] * v5[6]) + (-1 * v0[2] * v1[0] * v2[5] * v3[1] * v4[6] * v5[3]) + (-1 * v0[2] * v1[0] * v2[5] * v3[3] * v4[1] * v5[6]) + (v0[2] * v1[0] * v2[5] * v3[3] * v4[6] * v5[1]) + (v0[2] * v1[0] * v2[5] * v3[6] * v4[1] * v5[3]) + (-1 * v0[2] * v1[0] * v2[5] * v3[6] * v4[3] * v5[1]) + (-1 * v0[2] * v1[0] * v2[6] * v3[1] * v4[3] * v5[5]) + (v0[2] * v1[0] * v2[6] * v3[1] * v4[5] * v5[3]) + (v0[2] * v1[0] * v2[6] * v3[3] * v4[1] * v5[5]) + (-1 * v0[2] * v1[0] * v2[6] * v3[3] * v4[5] * v5[1]) + (-1 * v0[2] * v1[0] * v2[6] * v3[5] * v4[1] * v5[3]) + (v0[2] * v1[0] * v2[6] * v3[5] * v4[3] * v5[1]) + (-1 * v0[2] * v1[1] * v2[0] * v3[3] * v4[5] * v5[6]) + (v0[2] * v1[1] * v2[0] * v3[3] * v4[6] * v5[5]) + (v0[2] * v1[1] * v2[0] * v3[5] * v4[3] * v5[6]) + (-1 * v0[2] * v1[1] * v2[0] * v3[5] * v4[6] * v5[3]) + (-1 * v0[2] * v1[1] * v2[0] * v3[6] * v4[3] * v5[5]) + (v0[2] * v1[1] * v2[0] * v3[6] * v4[5] * v5[3]) + (v0[2] * v1[1] * v2[3] * v3[0] * v4[5] * v5[6]) + (-1 * v0[2] * v1[1] * v2[3] * v3[0] * v4[6] * v5[5]) + (-1 * v0[2] * v1[1] * v2[3] * v3[5] * v4[0] * v5[6]) + (v0[2] * v1[1] * v2[3] * v3[5] * v4[6] * v5[0]) + (v0[2] * v1[1] * v2[3] * v3[6] * v4[0] * v5[5]) + (-1 * v0[2] * v1[1] * v2[3] * v3[6] * v4[5] * v5[0]) + (-1 * v0[2] * v1[1] * v2[5] * v3[0] * v4[3] * v5[6]) + (v0[2] * v1[1] * v2[5] * v3[0] * v4[6] * v5[3]) + (v0[2] * v1[1] * v2[5] * v3[3] * v4[0] * v5[6]) + (-1 * v0[2] * v1[1] * v2[5] * v3[3] * v4[6] * v5[0]) + (-1 * v0[2] * v1[1] * v2[5] * v3[6] * v4[0] * v5[3]) + (v0[2] * v1[1] * v2[5] * v3[6] * v4[3] * v5[0]) + (v0[2] * v1[1] * v2[6] * v3[0] * v4[3] * v5[5]) + (-1 * v0[2] * v1[1] * v2[6] * v3[0] * v4[5] * v5[3]) + (-1 * v0[2] * v1[1] * v2[6] * v3[3] * v4[0] * v5[5]) + (v0[2] * v1[1] * v2[6] * v3[3] * v4[5] * v5[0]) + (v0[2] * v1[1] * v2[6] * v3[5] * v4[0] * v5[3]) + (-1 * v0[2] * v1[1] * v2[6] * v3[5] * v4[3] * v5[0]) + (v0[2] * v1[3] * v2[0] * v3[1] * v4[5] * v5[6]) + (-1 * v0[2] * v1[3] * v2[0] * v3[1] * v4[6] * v5[5]) + (-1 * v0[2] * v1[3] * v2[0] * v3[5] * v4[1] * v5[6]) + (v0[2] * v1[3] * v2[0] * v3[5] * v4[6] * v5[1]) + (v0[2] * v1[3] * v2[0] * v3[6] * v4[1] * v5[5]) + (-1 * v0[2] * v1[3] * v2[0] * v3[6] * v4[5] * v5[1]) + (-1 * v0[2] * v1[3] * v2[1] * v3[0] * v4[5] * v5[6]) + (v0[2] * v1[3] * v2[1] * v3[0] * v4[6] * v5[5]) + (v0[2] * v1[3] * v2[1] * v3[5] * v4[0] * v5[6]) + (-1 * v0[2] * v1[3] * v2[1] * v3[5] * v4[6] * v5[0]) + (-1 * v0[2] * v1[3] * v2[1] * v3[6] * v4[0] * v5[5]) + (v0[2] * v1[3] * v2[1] * v3[6] * v4[5] * v5[0]) + (v0[2] * v1[3] * v2[5] * v3[0] * v4[1] * v5[6]) + (-1 * v0[2] * v1[3] * v2[5] * v3[0] * v4[6] * v5[1]) + (-1 * v0[2] * v1[3] * v2[5] * v3[1] * v4[0] * v5[6]) + (v0[2] * v1[3] * v2[5] * v3[1] * v4[6] * v5[0]) + (v0[2] * v1[3] * v2[5] * v3[6] * v4[0] * v5[1]) + (-1 * v0[2] * v1[3] * v2[5] * v3[6] * v4[1] * v5[0]) + (-1 * v0[2] * v1[3] * v2[6] * v3[0] * v4[1] * v5[5]) + (v0[2] * v1[3] * v2[6] * v3[0] * v4[5] * v5[1]) + (v0[2] * v1[3] * v2[6] * v3[1] * v4[0] * v5[5]) + (-1 * v0[2] * v1[3] * v2[6] * v3[1] * v4[5] * v5[0]) + (-1 * v0[2] * v1[3] * v2[6] * v3[5] * v4[0] * v5[1]) + (v0[2] * v1[3] * v2[6] * v3[5] * v4[1] * v5[0]) + (-1 * v0[2] * v1[5] * v2[0] * v3[1] * v4[3] * v5[6]) + (v0[2] * v1[5] * v2[0] * v3[1] * v4[6] * v5[3]) + (v0[2] * v1[5] * v2[0] * v3[3] * v4[1] * v5[6]) + (-1 * v0[2] * v1[5] * v2[0] * v3[3] * v4[6] * v5[1]) + (-1 * v0[2] * v1[5] * v2[0] * v3[6] * v4[1] * v5[3]) + (v0[2] * v1[5] * v2[0] * v3[6] * v4[3] * v5[1]) + (v0[2] * v1[5] * v2[1] * v3[0] * v4[3] * v5[6]) + (-1 * v0[2] * v1[5] * v2[1] * v3[0] * v4[6] * v5[3]) + (-1 * v0[2] * v1[5] * v2[1] * v3[3] * v4[0] * v5[6]) + (v0[2] * v1[5] * v2[1] * v3[3] * v4[6] * v5[0]) + (v0[2] * v1[5] * v2[1] * v3[6] * v4[0] * v5[3]) + (-1 * v0[2] * v1[5] * v2[1] * v3[6] * v4[3] * v5[0]) + (-1 * v0[2] * v1[5] * v2[3] * v3[0] * v4[1] * v5[6]) + (v0[2] * v1[5] * v2[3] * v3[0] * v4[6] * v5[1]) + (v0[2] * v1[5] * v2[3] * v3[1] * v4[0] * v5[6]) + (-1 * v0[2] * v1[5] * v2[3] * v3[1] * v4[6] * v5[0]) + (-1 * v0[2] * v1[5] * v2[3] * v3[6] * v4[0] * v5[1]) + (v0[2] * v1[5] * v2[3] * v3[6] * v4[1] * v5[0]) + (v0[2] * v1[5] * v2[6] * v3[0] * v4[1] * v5[3]) + (-1 * v0[2] * v1[5] * v2[6] * v3[0] * v4[3] * v5[1]) + (-1 * v0[2] * v1[5] * v2[6] * v3[1] * v4[0] * v5[3]) + (v0[2] * v1[5] * v2[6] * v3[1] * v4[3] * v5[0]) + (v0[2] * v1[5] * v2[6] * v3[3] * v4[0] * v5[1]) + (-1 * v0[2] * v1[5] * v2[6] * v3[3] * v4[1] * v5[0]) + (v0[2] * v1[6] * v2[0] * v3[1] * v4[3] * v5[5]) + (-1 * v0[2] * v1[6] * v2[0] * v3[1] * v4[5] * v5[3]) + (-1 * v0[2] * v1[6] * v2[0] * v3[3] * v4[1] * v5[5]) + (v0[2] * v1[6] * v2[0] * v3[3] * v4[5] * v5[1]) + (v0[2] * v1[6] * v2[0] * v3[5] * v4[1] * v5[3]) + (-1 * v0[2] * v1[6] * v2[0] * v3[5] * v4[3] * v5[1]) + (-1 * v0[2] * v1[6] * v2[1] * v3[0] * v4[3] * v5[5]) + (v0[2] * v1[6] * v2[1] * v3[0] * v4[5] * v5[3]) + (v0[2] * v1[6] * v2[1] * v3[3] * v4[0] * v5[5]) + (-1 * v0[2] * v1[6] * v2[1] * v3[3] * v4[5] * v5[0]) + (-1 * v0[2] * v1[6] * v2[1] * v3[5] * v4[0] * v5[3]) + (v0[2] * v1[6] * v2[1] * v3[5] * v4[3] * v5[0]) + (v0[2] * v1[6] * v2[3] * v3[0] * v4[1] * v5[5]) + (-1 * v0[2] * v1[6] * v2[3] * v3[0] * v4[5] * v5[1]) + (-1 * v0[2] * v1[6] * v2[3] * v3[1] * v4[0] * v5[5]) + (v0[2] * v1[6] * v2[3] * v3[1] * v4[5] * v5[0]) + (v0[2] * v1[6] * v2[3] * v3[5] * v4[0] * v5[1]) + (-1 * v0[2] * v1[6] * v2[3] * v3[5] * v4[1] * v5[0]) + (-1 * v0[2] * v1[6] * v2[5] * v3[0] * v4[1] * v5[3]) + (v0[2] * v1[6] * v2[5] * v3[0] * v4[3] * v5[1]) + (v0[2] * v1[6] * v2[5] * v3[1] * v4[0] * v5[3]) + (-1 * v0[2] * v1[6] * v2[5] * v3[1] * v4[3] * v5[0]) + (-1 * v0[2] * v1[6] * v2[5] * v3[3] * v4[0] * v5[1]) + (v0[2] * v1[6] * v2[5] * v3[3] * v4[1] * v5[0]) + (-1 * v0[3] * v1[0] * v2[1] * v3[2] * v4[5] * v5[6]) + (v0[3] * v1[0] * v2[1] * v3[2] * v4[6] * v5[5]) + (v0[3] * v1[0] * v2[1] * v3[5] * v4[2] * v5[6]) + (-1 * v0[3] * v1[0] * v2[1] * v3[5] * v4[6] * v5[2]) + (-1 * v0[3] * v1[0] * v2[1] * v3[6] * v4[2] * v5[5]) + (v0[3] * v1[0] * v2[1] * v3[6] * v4[5] * v5[2]) + (v0[3] * v1[0] * v2[2] * v3[1] * v4[5] * v5[6]) + (-1 * v0[3] * v1[0] * v2[2] * v3[1] * v4[6] * v5[5]) + (-1 * v0[3] * v1[0] * v2[2] * v3[5] * v4[1] * v5[6]) + (v0[3] * v1[0] * v2[2] * v3[5] * v4[6] * v5[1]) + (v0[3] * v1[0] * v2[2] * v3[6] * v4[1] * v5[5]) + (-1 * v0[3] * v1[0] * v2[2] * v3[6] * v4[5] * v5[1]) + (-1 * v0[3] * v1[0] * v2[5] * v3[1] * v4[2] * v5[6]) + (v0[3] * v1[0] * v2[5] * v3[1] * v4[6] * v5[2]) + (v0[3] * v1[0] * v2[5] * v3[2] * v4[1] * v5[6]) + (-1 * v0[3] * v1[0] * v2[5] * v3[2] * v4[6] * v5[1]) + (-1 * v0[3] * v1[0] * v2[5] * v3[6] * v4[1] * v5[2]) + (v0[3] * v1[0] * v2[5] * v3[6] * v4[2] * v5[1]) + (v0[3] * v1[0] * v2[6] * v3[1] * v4[2] * v5[5]) + (-1 * v0[3] * v1[0] * v2[6] * v3[1] * v4[5] * v5[2]) + (-1 * v0[3] * v1[0] * v2[6] * v3[2] * v4[1] * v5[5]) + (v0[3] * v1[0] * v2[6] * v3[2] * v4[5] * v5[1]) + (v0[3] * v1[0] * v2[6] * v3[5] * v4[1] * v5[2]) + (-1 * v0[3] * v1[0] * v2[6] * v3[5] * v4[2] * v5[1]) + (v0[3] * v1[1] * v2[0] * v3[2] * v4[5] * v5[6]) + (-1 * v0[3] * v1[1] * v2[0] * v3[2] * v4[6] * v5[5]) + (-1 * v0[3] * v1[1] * v2[0] * v3[5] * v4[2] * v5[6]) + (v0[3] * v1[1] * v2[0] * v3[5] * v4[6] * v5[2]) + (v0[3] * v1[1] * v2[0] * v3[6] * v4[2] * v5[5]) + (-1 * v0[3] * v1[1] * v2[0] * v3[6] * v4[5] * v5[2]) + (-1 * v0[3] * v1[1] * v2[2] * v3[0] * v4[5] * v5[6]) + (v0[3] * v1[1] * v2[2] * v3[0] * v4[6] * v5[5]) + (v0[3] * v1[1] * v2[2] * v3[5] * v4[0] * v5[6]) + (-1 * v0[3] * v1[1] * v2[2] * v3[5] * v4[6] * v5[0]) + (-1 * v0[3] * v1[1] * v2[2] * v3[6] * v4[0] * v5[5]) + (v0[3] * v1[1] * v2[2] * v3[6] * v4[5] * v5[0]) + (v0[3] * v1[1] * v2[5] * v3[0] * v4[2] * v5[6]) + (-1 * v0[3] * v1[1] * v2[5] * v3[0] * v4[6] * v5[2]) + (-1 * v0[3] * v1[1] * v2[5] * v3[2] * v4[0] * v5[6]) + (v0[3] * v1[1] * v2[5] * v3[2] * v4[6] * v5[0]) + (v0[3] * v1[1] * v2[5] * v3[6] * v4[0] * v5[2]) + (-1 * v0[3] * v1[1] * v2[5] * v3[6] * v4[2] * v5[0]) + (-1 * v0[3] * v1[1] * v2[6] * v3[0] * v4[2] * v5[5]) + (v0[3] * v1[1] * v2[6] * v3[0] * v4[5] * v5[2]) + (v0[3] * v1[1] * v2[6] * v3[2] * v4[0] * v5[5]) + (-1 * v0[3] * v1[1] * v2[6] * v3[2] * v4[5] * v5[0]) + (-1 * v0[3] * v1[1] * v2[6] * v3[5] * v4[0] * v5[2]) + (v0[3] * v1[1] * v2[6] * v3[5] * v4[2] * v5[0]) + (-1 * v0[3] * v1[2] * v2[0] * v3[1] * v4[5] * v5[6]) + (v0[3] * v1[2] * v2[0] * v3[1] * v4[6] * v5[5]) + (v0[3] * v1[2] * v2[0] * v3[5] * v4[1] * v5[6]) + (-1 * v0[3] * v1[2] * v2[0] * v3[5] * v4[6] * v5[1]) + (-1 * v0[3] * v1[2] * v2[0] * v3[6] * v4[1] * v5[5]) + (v0[3] * v1[2] * v2[0] * v3[6] * v4[5] * v5[1]) + (v0[3] * v1[2] * v2[1] * v3[0] * v4[5] * v5[6]) + (-1 * v0[3] * v1[2] * v2[1] * v3[0] * v4[6] * v5[5]) + (-1 * v0[3] * v1[2] * v2[1] * v3[5] * v4[0] * v5[6]) + (v0[3] * v1[2] * v2[1] * v3[5] * v4[6] * v5[0]) + (v0[3] * v1[2] * v2[1] * v3[6] * v4[0] * v5[5]) + (-1 * v0[3] * v1[2] * v2[1] * v3[6] * v4[5] * v5[0]) + (-1 * v0[3] * v1[2] * v2[5] * v3[0] * v4[1] * v5[6]) + (v0[3] * v1[2] * v2[5] * v3[0] * v4[6] * v5[1]) + (v0[3] * v1[2] * v2[5] * v3[1] * v4[0] * v5[6]) + (-1 * v0[3] * v1[2] * v2[5] * v3[1] * v4[6] * v5[0]) + (-1 * v0[3] * v1[2] * v2[5] * v3[6] * v4[0] * v5[1]) + (v0[3] * v1[2] * v2[5] * v3[6] * v4[1] * v5[0]) + (v0[3] * v1[2] * v2[6] * v3[0] * v4[1] * v5[5]) + (-1 * v0[3] * v1[2] * v2[6] * v3[0] * v4[5] * v5[1]) + (-1 * v0[3] * v1[2] * v2[6] * v3[1] * v4[0] * v5[5]) + (v0[3] * v1[2] * v2[6] * v3[1] * v4[5] * v5[0]) + (v0[3] * v1[2] * v2[6] * v3[5] * v4[0] * v5[1]) + (-1 * v0[3] * v1[2] * v2[6] * v3[5] * v4[1] * v5[0]) + (v0[3] * v1[5] * v2[0] * v3[1] * v4[2] * v5[6]) + (-1 * v0[3] * v1[5] * v2[0] * v3[1] * v4[6] * v5[2]) + (-1 * v0[3] * v1[5] * v2[0] * v3[2] * v4[1] * v5[6]) + (v0[3] * v1[5] * v2[0] * v3[2] * v4[6] * v5[1]) + (v0[3] * v1[5] * v2[0] * v3[6] * v4[1] * v5[2]) + (-1 * v0[3] * v1[5] * v2[0] * v3[6] * v4[2] * v5[1]) + (-1 * v0[3] * v1[5] * v2[1] * v3[0] * v4[2] * v5[6]) + (v0[3] * v1[5] * v2[1] * v3[0] * v4[6] * v5[2]) + (v0[3] * v1[5] * v2[1] * v3[2] * v4[0] * v5[6]) + (-1 * v0[3] * v1[5] * v2[1] * v3[2] * v4[6] * v5[0]) + (-1 * v0[3] * v1[5] * v2[1] * v3[6] * v4[0] * v5[2]) + (v0[3] * v1[5] * v2[1] * v3[6] * v4[2] * v5[0]) + (v0[3] * v1[5] * v2[2] * v3[0] * v4[1] * v5[6]) + (-1 * v0[3] * v1[5] * v2[2] * v3[0] * v4[6] * v5[1]) + (-1 * v0[3] * v1[5] * v2[2] * v3[1] * v4[0] * v5[6]) + (v0[3] * v1[5] * v2[2] * v3[1] * v4[6] * v5[0]) + (v0[3] * v1[5] * v2[2] * v3[6] * v4[0] * v5[1]) + (-1 * v0[3] * v1[5] * v2[2] * v3[6] * v4[1] * v5[0]) + (-1 * v0[3] * v1[5] * v2[6] * v3[0] * v4[1] * v5[2]) + (v0[3] * v1[5] * v2[6] * v3[0] * v4[2] * v5[1]) + (v0[3] * v1[5] * v2[6] * v3[1] * v4[0] * v5[2]) + (-1 * v0[3] * v1[5] * v2[6] * v3[1] * v4[2] * v5[0]) + (-1 * v0[3] * v1[5] * v2[6] * v3[2] * v4[0] * v5[1]) + (v0[3] * v1[5] * v2[6] * v3[2] * v4[1] * v5[0]) + (-1 * v0[3] * v1[6] * v2[0] * v3[1] * v4[2] * v5[5]) + (v0[3] * v1[6] * v2[0] * v3[1] * v4[5] * v5[2]) + (v0[3] * v1[6] * v2[0] * v3[2] * v4[1] * v5[5]) + (-1 * v0[3] * v1[6] * v2[0] * v3[2] * v4[5] * v5[1]) + (-1 * v0[3] * v1[6] * v2[0] * v3[5] * v4[1] * v5[2]) + (v0[3] * v1[6] * v2[0] * v3[5] * v4[2] * v5[1]) + (v0[3] * v1[6] * v2[1] * v3[0] * v4[2] * v5[5]) + (-1 * v0[3] * v1[6] * v2[1] * v3[0] * v4[5] * v5[2]) + (-1 * v0[3] * v1[6] * v2[1] * v3[2] * v4[0] * v5[5]) + (v0[3] * v1[6] * v2[1] * v3[2] * v4[5] * v5[0]) + (v0[3] * v1[6] * v2[1] * v3[5] * v4[0] * v5[2]) + (-1 * v0[3] * v1[6] * v2[1] * v3[5] * v4[2] * v5[0]) + (-1 * v0[3] * v1[6] * v2[2] * v3[0] * v4[1] * v5[5]) + (v0[3] * v1[6] * v2[2] * v3[0] * v4[5] * v5[1]) + (v0[3] * v1[6] * v2[2] * v3[1] * v4[0] * v5[5]) + (-1 * v0[3] * v1[6] * v2[2] * v3[1] * v4[5] * v5[0]) + (-1 * v0[3] * v1[6] * v2[2] * v3[5] * v4[0] * v5[1]) + (v0[3] * v1[6] * v2[2] * v3[5] * v4[1] * v5[0]) + (v0[3] * v1[6] * v2[5] * v3[0] * v4[1] * v5[2]) + (-1 * v0[3] * v1[6] * v2[5] * v3[0] * v4[2] * v5[1]) + (-1 * v0[3] * v1[6] * v2[5] * v3[1] * v4[0] * v5[2]) + (v0[3] * v1[6] * v2[5] * v3[1] * v4[2] * v5[0]) + (v0[3] * v1[6] * v2[5] * v3[2] * v4[0] * v5[1]) + (-1 * v0[3] * v1[6] * v2[5] * v3[2] * v4[1] * v5[0]) + (v0[5] * v1[0] * v2[1] * v3[2] * v4[3] * v5[6]) + (-1 * v0[5] * v1[0] * v2[1] * v3[2] * v4[6] * v5[3]) + (-1 * v0[5] * v1[0] * v2[1] * v3[3] * v4[2] * v5[6]) + (v0[5] * v1[0] * v2[1] * v3[3] * v4[6] * v5[2]) + (v0[5] * v1[0] * v2[1] * v3[6] * v4[2] * v5[3]) + (-1 * v0[5] * v1[0] * v2[1] * v3[6] * v4[3] * v5[2]) + (-1 * v0[5] * v1[0] * v2[2] * v3[1] * v4[3] * v5[6]) + (v0[5] * v1[0] * v2[2] * v3[1] * v4[6] * v5[3]) + (v0[5] * v1[0] * v2[2] * v3[3] * v4[1] * v5[6]) + (-1 * v0[5] * v1[0] * v2[2] * v3[3] * v4[6] * v5[1]) + (-1 * v0[5] * v1[0] * v2[2] * v3[6] * v4[1] * v5[3]) + (v0[5] * v1[0] * v2[2] * v3[6] * v4[3] * v5[1]) + (v0[5] * v1[0] * v2[3] * v3[1] * v4[2] * v5[6]) + (-1 * v0[5] * v1[0] * v2[3] * v3[1] * v4[6] * v5[2]) + (-1 * v0[5] * v1[0] * v2[3] * v3[2] * v4[1] * v5[6]) + (v0[5] * v1[0] * v2[3] * v3[2] * v4[6] * v5[1]) + (v0[5] * v1[0] * v2[3] * v3[6] * v4[1] * v5[2]) + (-1 * v0[5] * v1[0] * v2[3] * v3[6] * v4[2] * v5[1]) + (-1 * v0[5] * v1[0] * v2[6] * v3[1] * v4[2] * v5[3]) + (v0[5] * v1[0] * v2[6] * v3[1] * v4[3] * v5[2]) + (v0[5] * v1[0] * v2[6] * v3[2] * v4[1] * v5[3]) + (-1 * v0[5] * v1[0] * v2[6] * v3[2] * v4[3] * v5[1]) + (-1 * v0[5] * v1[0] * v2[6] * v3[3] * v4[1] * v5[2]) + (v0[5] * v1[0] * v2[6] * v3[3] * v4[2] * v5[1]) + (-1 * v0[5] * v1[1] * v2[0] * v3[2] * v4[3] * v5[6]) + (v0[5] * v1[1] * v2[0] * v3[2] * v4[6] * v5[3]) + (v0[5] * v1[1] * v2[0] * v3[3] * v4[2] * v5[6]) + (-1 * v0[5] * v1[1] * v2[0] * v3[3] * v4[6] * v5[2]) + (-1 * v0[5] * v1[1] * v2[0] * v3[6] * v4[2] * v5[3]) + (v0[5] * v1[1] * v2[0] * v3[6] * v4[3] * v5[2]) + (v0[5] * v1[1] * v2[2] * v3[0] * v4[3] * v5[6]) + (-1 * v0[5] * v1[1] * v2[2] * v3[0] * v4[6] * v5[3]) + (-1 * v0[5] * v1[1] * v2[2] * v3[3] * v4[0] * v5[6]) + (v0[5] * v1[1] * v2[2] * v3[3] * v4[6] * v5[0]) + (v0[5] * v1[1] * v2[2] * v3[6] * v4[0] * v5[3]) + (-1 * v0[5] * v1[1] * v2[2] * v3[6] * v4[3] * v5[0]) + (-1 * v0[5] * v1[1] * v2[3] * v3[0] * v4[2] * v5[6]) + (v0[5] * v1[1] * v2[3] * v3[0] * v4[6] * v5[2]) + (v0[5] * v1[1] * v2[3] * v3[2] * v4[0] * v5[6]) + (-1 * v0[5] * v1[1] * v2[3] * v3[2] * v4[6] * v5[0]) + (-1 * v0[5] * v1[1] * v2[3] * v3[6] * v4[0] * v5[2]) + (v0[5] * v1[1] * v2[3] * v3[6] * v4[2] * v5[0]) + (v0[5] * v1[1] * v2[6] * v3[0] * v4[2] * v5[3]) + (-1 * v0[5] * v1[1] * v2[6] * v3[0] * v4[3] * v5[2]) + (-1 * v0[5] * v1[1] * v2[6] * v3[2] * v4[0] * v5[3]) + (v0[5] * v1[1] * v2[6] * v3[2] * v4[3] * v5[0]) + (v0[5] * v1[1] * v2[6] * v3[3] * v4[0] * v5[2]) + (-1 * v0[5] * v1[1] * v2[6] * v3[3] * v4[2] * v5[0]) + (v0[5] * v1[2] * v2[0] * v3[1] * v4[3] * v5[6]) + (-1 * v0[5] * v1[2] * v2[0] * v3[1] * v4[6] * v5[3]) + (-1 * v0[5] * v1[2] * v2[0] * v3[3] * v4[1] * v5[6]) + (v0[5] * v1[2] * v2[0] * v3[3] * v4[6] * v5[1]) + (v0[5] * v1[2] * v2[0] * v3[6] * v4[1] * v5[3]) + (-1 * v0[5] * v1[2] * v2[0] * v3[6] * v4[3] * v5[1]) + (-1 * v0[5] * v1[2] * v2[1] * v3[0] * v4[3] * v5[6]) + (v0[5] * v1[2] * v2[1] * v3[0] * v4[6] * v5[3]) + (v0[5] * v1[2] * v2[1] * v3[3] * v4[0] * v5[6]) + (-1 * v0[5] * v1[2] * v2[1] * v3[3] * v4[6] * v5[0]) + (-1 * v0[5] * v1[2] * v2[1] * v3[6] * v4[0] * v5[3]) + (v0[5] * v1[2] * v2[1] * v3[6] * v4[3] * v5[0]) + (v0[5] * v1[2] * v2[3] * v3[0] * v4[1] * v5[6]) + (-1 * v0[5] * v1[2] * v2[3] * v3[0] * v4[6] * v5[1]) + (-1 * v0[5] * v1[2] * v2[3] * v3[1] * v4[0] * v5[6]) + (v0[5] * v1[2] * v2[3] * v3[1] * v4[6] * v5[0]) + (v0[5] * v1[2] * v2[3] * v3[6] * v4[0] * v5[1]) + (-1 * v0[5] * v1[2] * v2[3] * v3[6] * v4[1] * v5[0]) + (-1 * v0[5] * v1[2] * v2[6] * v3[0] * v4[1] * v5[3]) + (v0[5] * v1[2] * v2[6] * v3[0] * v4[3] * v5[1]) + (v0[5] * v1[2] * v2[6] * v3[1] * v4[0] * v5[3]) + (-1 * v0[5] * v1[2] * v2[6] * v3[1] * v4[3] * v5[0]) + (-1 * v0[5] * v1[2] * v2[6] * v3[3] * v4[0] * v5[1]) + (v0[5] * v1[2] * v2[6] * v3[3] * v4[1] * v5[0]) + (-1 * v0[5] * v1[3] * v2[0] * v3[1] * v4[2] * v5[6]) + (v0[5] * v1[3] * v2[0] * v3[1] * v4[6] * v5[2]) + (v0[5] * v1[3] * v2[0] * v3[2] * v4[1] * v5[6]) + (-1 * v0[5] * v1[3] * v2[0] * v3[2] * v4[6] * v5[1]) + (-1 * v0[5] * v1[3] * v2[0] * v3[6] * v4[1] * v5[2]) + (v0[5] * v1[3] * v2[0] * v3[6] * v4[2] * v5[1]) + (v0[5] * v1[3] * v2[1] * v3[0] * v4[2] * v5[6]) + (-1 * v0[5] * v1[3] * v2[1] * v3[0] * v4[6] * v5[2]) + (-1 * v0[5] * v1[3] * v2[1] * v3[2] * v4[0] * v5[6]) + (v0[5] * v1[3] * v2[1] * v3[2] * v4[6] * v5[0]) + (v0[5] * v1[3] * v2[1] * v3[6] * v4[0] * v5[2]) + (-1 * v0[5] * v1[3] * v2[1] * v3[6] * v4[2] * v5[0]) + (-1 * v0[5] * v1[3] * v2[2] * v3[0] * v4[1] * v5[6]) + (v0[5] * v1[3] * v2[2] * v3[0] * v4[6] * v5[1]) + (v0[5] * v1[3] * v2[2] * v3[1] * v4[0] * v5[6]) + (-1 * v0[5] * v1[3] * v2[2] * v3[1] * v4[6] * v5[0]) + (-1 * v0[5] * v1[3] * v2[2] * v3[6] * v4[0] * v5[1]) + (v0[5] * v1[3] * v2[2] * v3[6] * v4[1] * v5[0]) + (v0[5] * v1[3] * v2[6] * v3[0] * v4[1] * v5[2]) + (-1 * v0[5] * v1[3] * v2[6] * v3[0] * v4[2] * v5[1]) + (-1 * v0[5] * v1[3] * v2[6] * v3[1] * v4[0] * v5[2]) + (v0[5] * v1[3] * v2[6] * v3[1] * v4[2] * v5[0]) + (v0[5] * v1[3] * v2[6] * v3[2] * v4[0] * v5[1]) + (-1 * v0[5] * v1[3] * v2[6] * v3[2] * v4[1] * v5[0]) + (v0[5] * v1[6] * v2[0] * v3[1] * v4[2] * v5[3]) + (-1 * v0[5] * v1[6] * v2[0] * v3[1] * v4[3] * v5[2]) + (-1 * v0[5] * v1[6] * v2[0] * v3[2] * v4[1] * v5[3]) + (v0[5] * v1[6] * v2[0] * v3[2] * v4[3] * v5[1]) + (v0[5] * v1[6] * v2[0] * v3[3] * v4[1] * v5[2]) + (-1 * v0[5] * v1[6] * v2[0] * v3[3] * v4[2] * v5[1]) + (-1 * v0[5] * v1[6] * v2[1] * v3[0] * v4[2] * v5[3]) + (v0[5] * v1[6] * v2[1] * v3[0] * v4[3] * v5[2]) + (v0[5] * v1[6] * v2[1] * v3[2] * v4[0] * v5[3]) + (-1 * v0[5] * v1[6] * v2[1] * v3[2] * v4[3] * v5[0]) + (-1 * v0[5] * v1[6] * v2[1] * v3[3] * v4[0] * v5[2]) + (v0[5] * v1[6] * v2[1] * v3[3] * v4[2] * v5[0]) + (v0[5] * v1[6] * v2[2] * v3[0] * v4[1] * v5[3]) + (-1 * v0[5] * v1[6] * v2[2] * v3[0] * v4[3] * v5[1]) + (-1 * v0[5] * v1[6] * v2[2] * v3[1] * v4[0] * v5[3]) + (v0[5] * v1[6] * v2[2] * v3[1] * v4[3] * v5[0]) + (v0[5] * v1[6] * v2[2] * v3[3] * v4[0] * v5[1]) + (-1 * v0[5] * v1[6] * v2[2] * v3[3] * v4[1] * v5[0]) + (-1 * v0[5] * v1[6] * v2[3] * v3[0] * v4[1] * v5[2]) + (v0[5] * v1[6] * v2[3] * v3[0] * v4[2] * v5[1]) + (v0[5] * v1[6] * v2[3] * v3[1] * v4[0] * v5[2]) + (-1 * v0[5] * v1[6] * v2[3] * v3[1] * v4[2] * v5[0]) + (-1 * v0[5] * v1[6] * v2[3] * v3[2] * v4[0] * v5[1]) + (v0[5] * v1[6] * v2[3] * v3[2] * v4[1] * v5[0]) + (-1 * v0[6] * v1[0] * v2[1] * v3[2] * v4[3] * v5[5]) + (v0[6] * v1[0] * v2[1] * v3[2] * v4[5] * v5[3]) + (v0[6] * v1[0] * v2[1] * v3[3] * v4[2] * v5[5]) + (-1 * v0[6] * v1[0] * v2[1] * v3[3] * v4[5] * v5[2]) + (-1 * v0[6] * v1[0] * v2[1] * v3[5] * v4[2] * v5[3]) + (v0[6] * v1[0] * v2[1] * v3[5] * v4[3] * v5[2]) + (v0[6] * v1[0] * v2[2] * v3[1] * v4[3] * v5[5]) + (-1 * v0[6] * v1[0] * v2[2] * v3[1] * v4[5] * v5[3]) + (-1 * v0[6] * v1[0] * v2[2] * v3[3] * v4[1] * v5[5]) + (v0[6] * v1[0] * v2[2] * v3[3] * v4[5] * v5[1]) + (v0[6] * v1[0] * v2[2] * v3[5] * v4[1] * v5[3]) + (-1 * v0[6] * v1[0] * v2[2] * v3[5] * v4[3] * v5[1]) + (-1 * v0[6] * v1[0] * v2[3] * v3[1] * v4[2] * v5[5]) + (v0[6] * v1[0] * v2[3] * v3[1] * v4[5] * v5[2]) + (v0[6] * v1[0] * v2[3] * v3[2] * v4[1] * v5[5]) + (-1 * v0[6] * v1[0] * v2[3] * v3[2] * v4[5] * v5[1]) + (-1 * v0[6] * v1[0] * v2[3] * v3[5] * v4[1] * v5[2]) + (v0[6] * v1[0] * v2[3] * v3[5] * v4[2] * v5[1]) + (v0[6] * v1[0] * v2[5] * v3[1] * v4[2] * v5[3]) + (-1 * v0[6] * v1[0] * v2[5] * v3[1] * v4[3] * v5[2]) + (-1 * v0[6] * v1[0] * v2[5] * v3[2] * v4[1] * v5[3]) + (v0[6] * v1[0] * v2[5] * v3[2] * v4[3] * v5[1]) + (v0[6] * v1[0] * v2[5] * v3[3] * v4[1] * v5[2]) + (-1 * v0[6] * v1[0] * v2[5] * v3[3] * v4[2] * v5[1]) + (v0[6] * v1[1] * v2[0] * v3[2] * v4[3] * v5[5]) + (-1 * v0[6] * v1[1] * v2[0] * v3[2] * v4[5] * v5[3]) + (-1 * v0[6] * v1[1] * v2[0] * v3[3] * v4[2] * v5[5]) + (v0[6] * v1[1] * v2[0] * v3[3] * v4[5] * v5[2]) + (v0[6] * v1[1] * v2[0] * v3[5] * v4[2] * v5[3]) + (-1 * v0[6] * v1[1] * v2[0] * v3[5] * v4[3] * v5[2]) + (-1 * v0[6] * v1[1] * v2[2] * v3[0] * v4[3] * v5[5]) + (v0[6] * v1[1] * v2[2] * v3[0] * v4[5] * v5[3]) + (v0[6] * v1[1] * v2[2] * v3[3] * v4[0] * v5[5]) + (-1 * v0[6] * v1[1] * v2[2] * v3[3] * v4[5] * v5[0]) + (-1 * v0[6] * v1[1] * v2[2] * v3[5] * v4[0] * v5[3]) + (v0[6] * v1[1] * v2[2] * v3[5] * v4[3] * v5[0]) + (v0[6] * v1[1] * v2[3] * v3[0] * v4[2] * v5[5]) + (-1 * v0[6] * v1[1] * v2[3] * v3[0] * v4[5] * v5[2]) + (-1 * v0[6] * v1[1] * v2[3] * v3[2] * v4[0] * v5[5]) + (v0[6] * v1[1] * v2[3] * v3[2] * v4[5] * v5[0]) + (v0[6] * v1[1] * v2[3] * v3[5] * v4[0] * v5[2]) + (-1 * v0[6] * v1[1] * v2[3] * v3[5] * v4[2] * v5[0]) + (-1 * v0[6] * v1[1] * v2[5] * v3[0] * v4[2] * v5[3]) + (v0[6] * v1[1] * v2[5] * v3[0] * v4[3] * v5[2]) + (v0[6] * v1[1] * v2[5] * v3[2] * v4[0] * v5[3]) + (-1 * v0[6] * v1[1] * v2[5] * v3[2] * v4[3] * v5[0]) + (-1 * v0[6] * v1[1] * v2[5] * v3[3] * v4[0] * v5[2]) + (v0[6] * v1[1] * v2[5] * v3[3] * v4[2] * v5[0]) + (-1 * v0[6] * v1[2] * v2[0] * v3[1] * v4[3] * v5[5]) + (v0[6] * v1[2] * v2[0] * v3[1] * v4[5] * v5[3]) + (v0[6] * v1[2] * v2[0] * v3[3] * v4[1] * v5[5]) + (-1 * v0[6] * v1[2] * v2[0] * v3[3] * v4[5] * v5[1]) + (-1 * v0[6] * v1[2] * v2[0] * v3[5] * v4[1] * v5[3]) + (v0[6] * v1[2] * v2[0] * v3[5] * v4[3] * v5[1]) + (v0[6] * v1[2] * v2[1] * v3[0] * v4[3] * v5[5]) + (-1 * v0[6] * v1[2] * v2[1] * v3[0] * v4[5] * v5[3]) + (-1 * v0[6] * v1[2] * v2[1] * v3[3] * v4[0] * v5[5]) + (v0[6] * v1[2] * v2[1] * v3[3] * v4[5] * v5[0]) + (v0[6] * v1[2] * v2[1] * v3[5] * v4[0] * v5[3]) + (-1 * v0[6] * v1[2] * v2[1] * v3[5] * v4[3] * v5[0]) + (-1 * v0[6] * v1[2] * v2[3] * v3[0] * v4[1] * v5[5]) + (v0[6] * v1[2] * v2[3] * v3[0] * v4[5] * v5[1]) + (v0[6] * v1[2] * v2[3] * v3[1] * v4[0] * v5[5]) + (-1 * v0[6] * v1[2] * v2[3] * v3[1] * v4[5] * v5[0]) + (-1 * v0[6] * v1[2] * v2[3] * v3[5] * v4[0] * v5[1]) + (v0[6] * v1[2] * v2[3] * v3[5] * v4[1] * v5[0]) + (v0[6] * v1[2] * v2[5] * v3[0] * v4[1] * v5[3]) + (-1 * v0[6] * v1[2] * v2[5] * v3[0] * v4[3] * v5[1]) + (-1 * v0[6] * v1[2] * v2[5] * v3[1] * v4[0] * v5[3]) + (v0[6] * v1[2] * v2[5] * v3[1] * v4[3] * v5[0]) + (v0[6] * v1[2] * v2[5] * v3[3] * v4[0] * v5[1]) + (-1 * v0[6] * v1[2] * v2[5] * v3[3] * v4[1] * v5[0]) + (v0[6] * v1[3] * v2[0] * v3[1] * v4[2] * v5[5]) + (-1 * v0[6] * v1[3] * v2[0] * v3[1] * v4[5] * v5[2]) + (-1 * v0[6] * v1[3] * v2[0] * v3[2] * v4[1] * v5[5]) + (v0[6] * v1[3] * v2[0] * v3[2] * v4[5] * v5[1]) + (v0[6] * v1[3] * v2[0] * v3[5] * v4[1] * v5[2]) + (-1 * v0[6] * v1[3] * v2[0] * v3[5] * v4[2] * v5[1]) + (-1 * v0[6] * v1[3] * v2[1] * v3[0] * v4[2] * v5[5]) + (v0[6] * v1[3] * v2[1] * v3[0] * v4[5] * v5[2]) + (v0[6] * v1[3] * v2[1] * v3[2] * v4[0] * v5[5]) + (-1 * v0[6] * v1[3] * v2[1] * v3[2] * v4[5] * v5[0]) + (-1 * v0[6] * v1[3] * v2[1] * v3[5] * v4[0] * v5[2]) + (v0[6] * v1[3] * v2[1] * v3[5] * v4[2] * v5[0]) + (v0[6] * v1[3] * v2[2] * v3[0] * v4[1] * v5[5]) + (-1 * v0[6] * v1[3] * v2[2] * v3[0] * v4[5] * v5[1]) + (-1 * v0[6] * v1[3] * v2[2] * v3[1] * v4[0] * v5[5]) + (v0[6] * v1[3] * v2[2] * v3[1] * v4[5] * v5[0]) + (v0[6] * v1[3] * v2[2] * v3[5] * v4[0] * v5[1]) + (-1 * v0[6] * v1[3] * v2[2] * v3[5] * v4[1] * v5[0]) + (-1 * v0[6] * v1[3] * v2[5] * v3[0] * v4[1] * v5[2]) + (v0[6] * v1[3] * v2[5] * v3[0] * v4[2] * v5[1]) + (v0[6] * v1[3] * v2[5] * v3[1] * v4[0] * v5[2]) + (-1 * v0[6] * v1[3] * v2[5] * v3[1] * v4[2] * v5[0]) + (-1 * v0[6] * v1[3] * v2[5] * v3[2] * v4[0] * v5[1]) + (v0[6] * v1[3] * v2[5] * v3[2] * v4[1] * v5[0]) + (-1 * v0[6] * v1[5] * v2[0] * v3[1] * v4[2] * v5[3]) + (v0[6] * v1[5] * v2[0] * v3[1] * v4[3] * v5[2]) + (v0[6] * v1[5] * v2[0] * v3[2] * v4[1] * v5[3]) + (-1 * v0[6] * v1[5] * v2[0] * v3[2] * v4[3] * v5[1]) + (-1 * v0[6] * v1[5] * v2[0] * v3[3] * v4[1] * v5[2]) + (v0[6] * v1[5] * v2[0] * v3[3] * v4[2] * v5[1]) + (v0[6] * v1[5] * v2[1] * v3[0] * v4[2] * v5[3]) + (-1 * v0[6] * v1[5] * v2[1] * v3[0] * v4[3] * v5[2]) + (-1 * v0[6] * v1[5] * v2[1] * v3[2] * v4[0] * v5[3]) + (v0[6] * v1[5] * v2[1] * v3[2] * v4[3] * v5[0]) + (v0[6] * v1[5] * v2[1] * v3[3] * v4[0] * v5[2]) + (-1 * v0[6] * v1[5] * v2[1] * v3[3] * v4[2] * v5[0]) + (-1 * v0[6] * v1[5] * v2[2] * v3[0] * v4[1] * v5[3]) + (v0[6] * v1[5] * v2[2] * v3[0] * v4[3] * v5[1]) + (v0[6] * v1[5] * v2[2] * v3[1] * v4[0] * v5[3]) + (-1 * v0[6] * v1[5] * v2[2] * v3[1] * v4[3] * v5[0]) + (-1 * v0[6] * v1[5] * v2[2] * v3[3] * v4[0] * v5[1]) + (v0[6] * v1[5] * v2[2] * v3[3] * v4[1] * v5[0]) + (v0[6] * v1[5] * v2[3] * v3[0] * v4[1] * v5[2]) + (-1 * v0[6] * v1[5] * v2[3] * v3[0] * v4[2] * v5[1]) + (-1 * v0[6] * v1[5] * v2[3] * v3[1] * v4[0] * v5[2]) + (v0[6] * v1[5] * v2[3] * v3[1] * v4[2] * v5[0]) + (v0[6] * v1[5] * v2[3] * v3[2] * v4[0] * v5[1]) + (-1 * v0[6] * v1[5] * v2[3] * v3[2] * v4[1] * v5[0]);
r0[5] = (-1 * v0[0] * v1[1] * v2[2] * v3[3] * v4[4] * v5[6]) + (v0[0] * v1[1] * v2[2] * v3[3] * v4[6] * v5[4]) + (v0[0] * v1[1] * v2[2] * v3[4] * v4[3] * v5[6]) + (-1 * v0[0] * v1[1] * v2[2] * v3[4] * v4[6] * v5[3]) + (-1 * v0[0] * v1[1] * v2[2] * v3[6] * v4[3] * v5[4]) + (v0[0] * v1[1] * v2[2] * v3[6] * v4[4] * v5[3]) + (v0[0] * v1[1] * v2[3] * v3[2] * v4[4] * v5[6]) + (-1 * v0[0] * v1[1] * v2[3] * v3[2] * v4[6] * v5[4]) + (-1 * v0[0] * v1[1] * v2[3] * v3[4] * v4[2] * v5[6]) + (v0[0] * v1[1] * v2[3] * v3[4] * v4[6] * v5[2]) + (v0[0] * v1[1] * v2[3] * v3[6] * v4[2] * v5[4]) + (-1 * v0[0] * v1[1] * v2[3] * v3[6] * v4[4] * v5[2]) + (-1 * v0[0] * v1[1] * v2[4] * v3[2] * v4[3] * v5[6]) + (v0[0] * v1[1] * v2[4] * v3[2] * v4[6] * v5[3]) + (v0[0] * v1[1] * v2[4] * v3[3] * v4[2] * v5[6]) + (-1 * v0[0] * v1[1] * v2[4] * v3[3] * v4[6] * v5[2]) + (-1 * v0[0] * v1[1] * v2[4] * v3[6] * v4[2] * v5[3]) + (v0[0] * v1[1] * v2[4] * v3[6] * v4[3] * v5[2]) + (v0[0] * v1[1] * v2[6] * v3[2] * v4[3] * v5[4]) + (-1 * v0[0] * v1[1] * v2[6] * v3[2] * v4[4] * v5[3]) + (-1 * v0[0] * v1[1] * v2[6] * v3[3] * v4[2] * v5[4]) + (v0[0] * v1[1] * v2[6] * v3[3] * v4[4] * v5[2]) + (v0[0] * v1[1] * v2[6] * v3[4] * v4[2] * v5[3]) + (-1 * v0[0] * v1[1] * v2[6] * v3[4] * v4[3] * v5[2]) + (v0[0] * v1[2] * v2[1] * v3[3] * v4[4] * v5[6]) + (-1 * v0[0] * v1[2] * v2[1] * v3[3] * v4[6] * v5[4]) + (-1 * v0[0] * v1[2] * v2[1] * v3[4] * v4[3] * v5[6]) + (v0[0] * v1[2] * v2[1] * v3[4] * v4[6] * v5[3]) + (v0[0] * v1[2] * v2[1] * v3[6] * v4[3] * v5[4]) + (-1 * v0[0] * v1[2] * v2[1] * v3[6] * v4[4] * v5[3]) + (-1 * v0[0] * v1[2] * v2[3] * v3[1] * v4[4] * v5[6]) + (v0[0] * v1[2] * v2[3] * v3[1] * v4[6] * v5[4]) + (v0[0] * v1[2] * v2[3] * v3[4] * v4[1] * v5[6]) + (-1 * v0[0] * v1[2] * v2[3] * v3[4] * v4[6] * v5[1]) + (-1 * v0[0] * v1[2] * v2[3] * v3[6] * v4[1] * v5[4]) + (v0[0] * v1[2] * v2[3] * v3[6] * v4[4] * v5[1]) + (v0[0] * v1[2] * v2[4] * v3[1] * v4[3] * v5[6]) + (-1 * v0[0] * v1[2] * v2[4] * v3[1] * v4[6] * v5[3]) + (-1 * v0[0] * v1[2] * v2[4] * v3[3] * v4[1] * v5[6]) + (v0[0] * v1[2] * v2[4] * v3[3] * v4[6] * v5[1]) + (v0[0] * v1[2] * v2[4] * v3[6] * v4[1] * v5[3]) + (-1 * v0[0] * v1[2] * v2[4] * v3[6] * v4[3] * v5[1]) + (-1 * v0[0] * v1[2] * v2[6] * v3[1] * v4[3] * v5[4]) + (v0[0] * v1[2] * v2[6] * v3[1] * v4[4] * v5[3]) + (v0[0] * v1[2] * v2[6] * v3[3] * v4[1] * v5[4]) + (-1 * v0[0] * v1[2] * v2[6] * v3[3] * v4[4] * v5[1]) + (-1 * v0[0] * v1[2] * v2[6] * v3[4] * v4[1] * v5[3]) + (v0[0] * v1[2] * v2[6] * v3[4] * v4[3] * v5[1]) + (-1 * v0[0] * v1[3] * v2[1] * v3[2] * v4[4] * v5[6]) + (v0[0] * v1[3] * v2[1] * v3[2] * v4[6] * v5[4]) + (v0[0] * v1[3] * v2[1] * v3[4] * v4[2] * v5[6]) + (-1 * v0[0] * v1[3] * v2[1] * v3[4] * v4[6] * v5[2]) + (-1 * v0[0] * v1[3] * v2[1] * v3[6] * v4[2] * v5[4]) + (v0[0] * v1[3] * v2[1] * v3[6] * v4[4] * v5[2]) + (v0[0] * v1[3] * v2[2] * v3[1] * v4[4] * v5[6]) + (-1 * v0[0] * v1[3] * v2[2] * v3[1] * v4[6] * v5[4]) + (-1 * v0[0] * v1[3] * v2[2] * v3[4] * v4[1] * v5[6]) + (v0[0] * v1[3] * v2[2] * v3[4] * v4[6] * v5[1]) + (v0[0] * v1[3] * v2[2] * v3[6] * v4[1] * v5[4]) + (-1 * v0[0] * v1[3] * v2[2] * v3[6] * v4[4] * v5[1]) + (-1 * v0[0] * v1[3] * v2[4] * v3[1] * v4[2] * v5[6]) + (v0[0] * v1[3] * v2[4] * v3[1] * v4[6] * v5[2]) + (v0[0] * v1[3] * v2[4] * v3[2] * v4[1] * v5[6]) + (-1 * v0[0] * v1[3] * v2[4] * v3[2] * v4[6] * v5[1]) + (-1 * v0[0] * v1[3] * v2[4] * v3[6] * v4[1] * v5[2]) + (v0[0] * v1[3] * v2[4] * v3[6] * v4[2] * v5[1]) + (v0[0] * v1[3] * v2[6] * v3[1] * v4[2] * v5[4]) + (-1 * v0[0] * v1[3] * v2[6] * v3[1] * v4[4] * v5[2]) + (-1 * v0[0] * v1[3] * v2[6] * v3[2] * v4[1] * v5[4]) + (v0[0] * v1[3] * v2[6] * v3[2] * v4[4] * v5[1]) + (v0[0] * v1[3] * v2[6] * v3[4] * v4[1] * v5[2]) + (-1 * v0[0] * v1[3] * v2[6] * v3[4] * v4[2] * v5[1]) + (v0[0] * v1[4] * v2[1] * v3[2] * v4[3] * v5[6]) + (-1 * v0[0] * v1[4] * v2[1] * v3[2] * v4[6] * v5[3]) + (-1 * v0[0] * v1[4] * v2[1] * v3[3] * v4[2] * v5[6]) + (v0[0] * v1[4] * v2[1] * v3[3] * v4[6] * v5[2]) + (v0[0] * v1[4] * v2[1] * v3[6] * v4[2] * v5[3]) + (-1 * v0[0] * v1[4] * v2[1] * v3[6] * v4[3] * v5[2]) + (-1 * v0[0] * v1[4] * v2[2] * v3[1] * v4[3] * v5[6]) + (v0[0] * v1[4] * v2[2] * v3[1] * v4[6] * v5[3]) + (v0[0] * v1[4] * v2[2] * v3[3] * v4[1] * v5[6]) + (-1 * v0[0] * v1[4] * v2[2] * v3[3] * v4[6] * v5[1]) + (-1 * v0[0] * v1[4] * v2[2] * v3[6] * v4[1] * v5[3]) + (v0[0] * v1[4] * v2[2] * v3[6] * v4[3] * v5[1]) + (v0[0] * v1[4] * v2[3] * v3[1] * v4[2] * v5[6]) + (-1 * v0[0] * v1[4] * v2[3] * v3[1] * v4[6] * v5[2]) + (-1 * v0[0] * v1[4] * v2[3] * v3[2] * v4[1] * v5[6]) + (v0[0] * v1[4] * v2[3] * v3[2] * v4[6] * v5[1]) + (v0[0] * v1[4] * v2[3] * v3[6] * v4[1] * v5[2]) + (-1 * v0[0] * v1[4] * v2[3] * v3[6] * v4[2] * v5[1]) + (-1 * v0[0] * v1[4] * v2[6] * v3[1] * v4[2] * v5[3]) + (v0[0] * v1[4] * v2[6] * v3[1] * v4[3] * v5[2]) + (v0[0] * v1[4] * v2[6] * v3[2] * v4[1] * v5[3]) + (-1 * v0[0] * v1[4] * v2[6] * v3[2] * v4[3] * v5[1]) + (-1 * v0[0] * v1[4] * v2[6] * v3[3] * v4[1] * v5[2]) + (v0[0] * v1[4] * v2[6] * v3[3] * v4[2] * v5[1]) + (-1 * v0[0] * v1[6] * v2[1] * v3[2] * v4[3] * v5[4]) + (v0[0] * v1[6] * v2[1] * v3[2] * v4[4] * v5[3]) + (v0[0] * v1[6] * v2[1] * v3[3] * v4[2] * v5[4]) + (-1 * v0[0] * v1[6] * v2[1] * v3[3] * v4[4] * v5[2]) + (-1 * v0[0] * v1[6] * v2[1] * v3[4] * v4[2] * v5[3]) + (v0[0] * v1[6] * v2[1] * v3[4] * v4[3] * v5[2]) + (v0[0] * v1[6] * v2[2] * v3[1] * v4[3] * v5[4]) + (-1 * v0[0] * v1[6] * v2[2] * v3[1] * v4[4] * v5[3]) + (-1 * v0[0] * v1[6] * v2[2] * v3[3] * v4[1] * v5[4]) + (v0[0] * v1[6] * v2[2] * v3[3] * v4[4] * v5[1]) + (v0[0] * v1[6] * v2[2] * v3[4] * v4[1] * v5[3]) + (-1 * v0[0] * v1[6] * v2[2] * v3[4] * v4[3] * v5[1]) + (-1 * v0[0] * v1[6] * v2[3] * v3[1] * v4[2] * v5[4]) + (v0[0] * v1[6] * v2[3] * v3[1] * v4[4] * v5[2]) + (v0[0] * v1[6] * v2[3] * v3[2] * v4[1] * v5[4]) + (-1 * v0[0] * v1[6] * v2[3] * v3[2] * v4[4] * v5[1]) + (-1 * v0[0] * v1[6] * v2[3] * v3[4] * v4[1] * v5[2]) + (v0[0] * v1[6] * v2[3] * v3[4] * v4[2] * v5[1]) + (v0[0] * v1[6] * v2[4] * v3[1] * v4[2] * v5[3]) + (-1 * v0[0] * v1[6] * v2[4] * v3[1] * v4[3] * v5[2]) + (-1 * v0[0] * v1[6] * v2[4] * v3[2] * v4[1] * v5[3]) + (v0[0] * v1[6] * v2[4] * v3[2] * v4[3] * v5[1]) + (v0[0] * v1[6] * v2[4] * v3[3] * v4[1] * v5[2]) + (-1 * v0[0] * v1[6] * v2[4] * v3[3] * v4[2] * v5[1]) + (v0[1] * v1[0] * v2[2] * v3[3] * v4[4] * v5[6]) + (-1 * v0[1] * v1[0] * v2[2] * v3[3] * v4[6] * v5[4]) + (-1 * v0[1] * v1[0] * v2[2] * v3[4] * v4[3] * v5[6]) + (v0[1] * v1[0] * v2[2] * v3[4] * v4[6] * v5[3]) + (v0[1] * v1[0] * v2[2] * v3[6] * v4[3] * v5[4]) + (-1 * v0[1] * v1[0] * v2[2] * v3[6] * v4[4] * v5[3]) + (-1 * v0[1] * v1[0] * v2[3] * v3[2] * v4[4] * v5[6]) + (v0[1] * v1[0] * v2[3] * v3[2] * v4[6] * v5[4]) + (v0[1] * v1[0] * v2[3] * v3[4] * v4[2] * v5[6]) + (-1 * v0[1] * v1[0] * v2[3] * v3[4] * v4[6] * v5[2]) + (-1 * v0[1] * v1[0] * v2[3] * v3[6] * v4[2] * v5[4]) + (v0[1] * v1[0] * v2[3] * v3[6] * v4[4] * v5[2]) + (v0[1] * v1[0] * v2[4] * v3[2] * v4[3] * v5[6]) + (-1 * v0[1] * v1[0] * v2[4] * v3[2] * v4[6] * v5[3]) + (-1 * v0[1] * v1[0] * v2[4] * v3[3] * v4[2] * v5[6]) + (v0[1] * v1[0] * v2[4] * v3[3] * v4[6] * v5[2]) + (v0[1] * v1[0] * v2[4] * v3[6] * v4[2] * v5[3]) + (-1 * v0[1] * v1[0] * v2[4] * v3[6] * v4[3] * v5[2]) + (-1 * v0[1] * v1[0] * v2[6] * v3[2] * v4[3] * v5[4]) + (v0[1] * v1[0] * v2[6] * v3[2] * v4[4] * v5[3]) + (v0[1] * v1[0] * v2[6] * v3[3] * v4[2] * v5[4]) + (-1 * v0[1] * v1[0] * v2[6] * v3[3] * v4[4] * v5[2]) + (-1 * v0[1] * v1[0] * v2[6] * v3[4] * v4[2] * v5[3]) + (v0[1] * v1[0] * v2[6] * v3[4] * v4[3] * v5[2]) + (-1 * v0[1] * v1[2] * v2[0] * v3[3] * v4[4] * v5[6]) + (v0[1] * v1[2] * v2[0] * v3[3] * v4[6] * v5[4]) + (v0[1] * v1[2] * v2[0] * v3[4] * v4[3] * v5[6]) + (-1 * v0[1] * v1[2] * v2[0] * v3[4] * v4[6] * v5[3]) + (-1 * v0[1] * v1[2] * v2[0] * v3[6] * v4[3] * v5[4]) + (v0[1] * v1[2] * v2[0] * v3[6] * v4[4] * v5[3]) + (v0[1] * v1[2] * v2[3] * v3[0] * v4[4] * v5[6]) + (-1 * v0[1] * v1[2] * v2[3] * v3[0] * v4[6] * v5[4]) + (-1 * v0[1] * v1[2] * v2[3] * v3[4] * v4[0] * v5[6]) + (v0[1] * v1[2] * v2[3] * v3[4] * v4[6] * v5[0]) + (v0[1] * v1[2] * v2[3] * v3[6] * v4[0] * v5[4]) + (-1 * v0[1] * v1[2] * v2[3] * v3[6] * v4[4] * v5[0]) + (-1 * v0[1] * v1[2] * v2[4] * v3[0] * v4[3] * v5[6]) + (v0[1] * v1[2] * v2[4] * v3[0] * v4[6] * v5[3]) + (v0[1] * v1[2] * v2[4] * v3[3] * v4[0] * v5[6]) + (-1 * v0[1] * v1[2] * v2[4] * v3[3] * v4[6] * v5[0]) + (-1 * v0[1] * v1[2] * v2[4] * v3[6] * v4[0] * v5[3]) + (v0[1] * v1[2] * v2[4] * v3[6] * v4[3] * v5[0]) + (v0[1] * v1[2] * v2[6] * v3[0] * v4[3] * v5[4]) + (-1 * v0[1] * v1[2] * v2[6] * v3[0] * v4[4] * v5[3]) + (-1 * v0[1] * v1[2] * v2[6] * v3[3] * v4[0] * v5[4]) + (v0[1] * v1[2] * v2[6] * v3[3] * v4[4] * v5[0]) + (v0[1] * v1[2] * v2[6] * v3[4] * v4[0] * v5[3]) + (-1 * v0[1] * v1[2] * v2[6] * v3[4] * v4[3] * v5[0]) + (v0[1] * v1[3] * v2[0] * v3[2] * v4[4] * v5[6]) + (-1 * v0[1] * v1[3] * v2[0] * v3[2] * v4[6] * v5[4]) + (-1 * v0[1] * v1[3] * v2[0] * v3[4] * v4[2] * v5[6]) + (v0[1] * v1[3] * v2[0] * v3[4] * v4[6] * v5[2]) + (v0[1] * v1[3] * v2[0] * v3[6] * v4[2] * v5[4]) + (-1 * v0[1] * v1[3] * v2[0] * v3[6] * v4[4] * v5[2]) + (-1 * v0[1] * v1[3] * v2[2] * v3[0] * v4[4] * v5[6]) + (v0[1] * v1[3] * v2[2] * v3[0] * v4[6] * v5[4]) + (v0[1] * v1[3] * v2[2] * v3[4] * v4[0] * v5[6]) + (-1 * v0[1] * v1[3] * v2[2] * v3[4] * v4[6] * v5[0]) + (-1 * v0[1] * v1[3] * v2[2] * v3[6] * v4[0] * v5[4]) + (v0[1] * v1[3] * v2[2] * v3[6] * v4[4] * v5[0]) + (v0[1] * v1[3] * v2[4] * v3[0] * v4[2] * v5[6]) + (-1 * v0[1] * v1[3] * v2[4] * v3[0] * v4[6] * v5[2]) + (-1 * v0[1] * v1[3] * v2[4] * v3[2] * v4[0] * v5[6]) + (v0[1] * v1[3] * v2[4] * v3[2] * v4[6] * v5[0]) + (v0[1] * v1[3] * v2[4] * v3[6] * v4[0] * v5[2]) + (-1 * v0[1] * v1[3] * v2[4] * v3[6] * v4[2] * v5[0]) + (-1 * v0[1] * v1[3] * v2[6] * v3[0] * v4[2] * v5[4]) + (v0[1] * v1[3] * v2[6] * v3[0] * v4[4] * v5[2]) + (v0[1] * v1[3] * v2[6] * v3[2] * v4[0] * v5[4]) + (-1 * v0[1] * v1[3] * v2[6] * v3[2] * v4[4] * v5[0]) + (-1 * v0[1] * v1[3] * v2[6] * v3[4] * v4[0] * v5[2]) + (v0[1] * v1[3] * v2[6] * v3[4] * v4[2] * v5[0]) + (-1 * v0[1] * v1[4] * v2[0] * v3[2] * v4[3] * v5[6]) + (v0[1] * v1[4] * v2[0] * v3[2] * v4[6] * v5[3]) + (v0[1] * v1[4] * v2[0] * v3[3] * v4[2] * v5[6]) + (-1 * v0[1] * v1[4] * v2[0] * v3[3] * v4[6] * v5[2]) + (-1 * v0[1] * v1[4] * v2[0] * v3[6] * v4[2] * v5[3]) + (v0[1] * v1[4] * v2[0] * v3[6] * v4[3] * v5[2]) + (v0[1] * v1[4] * v2[2] * v3[0] * v4[3] * v5[6]) + (-1 * v0[1] * v1[4] * v2[2] * v3[0] * v4[6] * v5[3]) + (-1 * v0[1] * v1[4] * v2[2] * v3[3] * v4[0] * v5[6]) + (v0[1] * v1[4] * v2[2] * v3[3] * v4[6] * v5[0]) + (v0[1] * v1[4] * v2[2] * v3[6] * v4[0] * v5[3]) + (-1 * v0[1] * v1[4] * v2[2] * v3[6] * v4[3] * v5[0]) + (-1 * v0[1] * v1[4] * v2[3] * v3[0] * v4[2] * v5[6]) + (v0[1] * v1[4] * v2[3] * v3[0] * v4[6] * v5[2]) + (v0[1] * v1[4] * v2[3] * v3[2] * v4[0] * v5[6]) + (-1 * v0[1] * v1[4] * v2[3] * v3[2] * v4[6] * v5[0]) + (-1 * v0[1] * v1[4] * v2[3] * v3[6] * v4[0] * v5[2]) + (v0[1] * v1[4] * v2[3] * v3[6] * v4[2] * v5[0]) + (v0[1] * v1[4] * v2[6] * v3[0] * v4[2] * v5[3]) + (-1 * v0[1] * v1[4] * v2[6] * v3[0] * v4[3] * v5[2]) + (-1 * v0[1] * v1[4] * v2[6] * v3[2] * v4[0] * v5[3]) + (v0[1] * v1[4] * v2[6] * v3[2] * v4[3] * v5[0]) + (v0[1] * v1[4] * v2[6] * v3[3] * v4[0] * v5[2]) + (-1 * v0[1] * v1[4] * v2[6] * v3[3] * v4[2] * v5[0]) + (v0[1] * v1[6] * v2[0] * v3[2] * v4[3] * v5[4]) + (-1 * v0[1] * v1[6] * v2[0] * v3[2] * v4[4] * v5[3]) + (-1 * v0[1] * v1[6] * v2[0] * v3[3] * v4[2] * v5[4]) + (v0[1] * v1[6] * v2[0] * v3[3] * v4[4] * v5[2]) + (v0[1] * v1[6] * v2[0] * v3[4] * v4[2] * v5[3]) + (-1 * v0[1] * v1[6] * v2[0] * v3[4] * v4[3] * v5[2]) + (-1 * v0[1] * v1[6] * v2[2] * v3[0] * v4[3] * v5[4]) + (v0[1] * v1[6] * v2[2] * v3[0] * v4[4] * v5[3]) + (v0[1] * v1[6] * v2[2] * v3[3] * v4[0] * v5[4]) + (-1 * v0[1] * v1[6] * v2[2] * v3[3] * v4[4] * v5[0]) + (-1 * v0[1] * v1[6] * v2[2] * v3[4] * v4[0] * v5[3]) + (v0[1] * v1[6] * v2[2] * v3[4] * v4[3] * v5[0]) + (v0[1] * v1[6] * v2[3] * v3[0] * v4[2] * v5[4]) + (-1 * v0[1] * v1[6] * v2[3] * v3[0] * v4[4] * v5[2]) + (-1 * v0[1] * v1[6] * v2[3] * v3[2] * v4[0] * v5[4]) + (v0[1] * v1[6] * v2[3] * v3[2] * v4[4] * v5[0]) + (v0[1] * v1[6] * v2[3] * v3[4] * v4[0] * v5[2]) + (-1 * v0[1] * v1[6] * v2[3] * v3[4] * v4[2] * v5[0]) + (-1 * v0[1] * v1[6] * v2[4] * v3[0] * v4[2] * v5[3]) + (v0[1] * v1[6] * v2[4] * v3[0] * v4[3] * v5[2]) + (v0[1] * v1[6] * v2[4] * v3[2] * v4[0] * v5[3]) + (-1 * v0[1] * v1[6] * v2[4] * v3[2] * v4[3] * v5[0]) + (-1 * v0[1] * v1[6] * v2[4] * v3[3] * v4[0] * v5[2]) + (v0[1] * v1[6] * v2[4] * v3[3] * v4[2] * v5[0]) + (-1 * v0[2] * v1[0] * v2[1] * v3[3] * v4[4] * v5[6]) + (v0[2] * v1[0] * v2[1] * v3[3] * v4[6] * v5[4]) + (v0[2] * v1[0] * v2[1] * v3[4] * v4[3] * v5[6]) + (-1 * v0[2] * v1[0] * v2[1] * v3[4] * v4[6] * v5[3]) + (-1 * v0[2] * v1[0] * v2[1] * v3[6] * v4[3] * v5[4]) + (v0[2] * v1[0] * v2[1] * v3[6] * v4[4] * v5[3]) + (v0[2] * v1[0] * v2[3] * v3[1] * v4[4] * v5[6]) + (-1 * v0[2] * v1[0] * v2[3] * v3[1] * v4[6] * v5[4]) + (-1 * v0[2] * v1[0] * v2[3] * v3[4] * v4[1] * v5[6]) + (v0[2] * v1[0] * v2[3] * v3[4] * v4[6] * v5[1]) + (v0[2] * v1[0] * v2[3] * v3[6] * v4[1] * v5[4]) + (-1 * v0[2] * v1[0] * v2[3] * v3[6] * v4[4] * v5[1]) + (-1 * v0[2] * v1[0] * v2[4] * v3[1] * v4[3] * v5[6]) + (v0[2] * v1[0] * v2[4] * v3[1] * v4[6] * v5[3]) + (v0[2] * v1[0] * v2[4] * v3[3] * v4[1] * v5[6]) + (-1 * v0[2] * v1[0] * v2[4] * v3[3] * v4[6] * v5[1]) + (-1 * v0[2] * v1[0] * v2[4] * v3[6] * v4[1] * v5[3]) + (v0[2] * v1[0] * v2[4] * v3[6] * v4[3] * v5[1]) + (v0[2] * v1[0] * v2[6] * v3[1] * v4[3] * v5[4]) + (-1 * v0[2] * v1[0] * v2[6] * v3[1] * v4[4] * v5[3]) + (-1 * v0[2] * v1[0] * v2[6] * v3[3] * v4[1] * v5[4]) + (v0[2] * v1[0] * v2[6] * v3[3] * v4[4] * v5[1]) + (v0[2] * v1[0] * v2[6] * v3[4] * v4[1] * v5[3]) + (-1 * v0[2] * v1[0] * v2[6] * v3[4] * v4[3] * v5[1]) + (v0[2] * v1[1] * v2[0] * v3[3] * v4[4] * v5[6]) + (-1 * v0[2] * v1[1] * v2[0] * v3[3] * v4[6] * v5[4]) + (-1 * v0[2] * v1[1] * v2[0] * v3[4] * v4[3] * v5[6]) + (v0[2] * v1[1] * v2[0] * v3[4] * v4[6] * v5[3]) + (v0[2] * v1[1] * v2[0] * v3[6] * v4[3] * v5[4]) + (-1 * v0[2] * v1[1] * v2[0] * v3[6] * v4[4] * v5[3]) + (-1 * v0[2] * v1[1] * v2[3] * v3[0] * v4[4] * v5[6]) + (v0[2] * v1[1] * v2[3] * v3[0] * v4[6] * v5[4]) + (v0[2] * v1[1] * v2[3] * v3[4] * v4[0] * v5[6]) + (-1 * v0[2] * v1[1] * v2[3] * v3[4] * v4[6] * v5[0]) + (-1 * v0[2] * v1[1] * v2[3] * v3[6] * v4[0] * v5[4]) + (v0[2] * v1[1] * v2[3] * v3[6] * v4[4] * v5[0]) + (v0[2] * v1[1] * v2[4] * v3[0] * v4[3] * v5[6]) + (-1 * v0[2] * v1[1] * v2[4] * v3[0] * v4[6] * v5[3]) + (-1 * v0[2] * v1[1] * v2[4] * v3[3] * v4[0] * v5[6]) + (v0[2] * v1[1] * v2[4] * v3[3] * v4[6] * v5[0]) + (v0[2] * v1[1] * v2[4] * v3[6] * v4[0] * v5[3]) + (-1 * v0[2] * v1[1] * v2[4] * v3[6] * v4[3] * v5[0]) + (-1 * v0[2] * v1[1] * v2[6] * v3[0] * v4[3] * v5[4]) + (v0[2] * v1[1] * v2[6] * v3[0] * v4[4] * v5[3]) + (v0[2] * v1[1] * v2[6] * v3[3] * v4[0] * v5[4]) + (-1 * v0[2] * v1[1] * v2[6] * v3[3] * v4[4] * v5[0]) + (-1 * v0[2] * v1[1] * v2[6] * v3[4] * v4[0] * v5[3]) + (v0[2] * v1[1] * v2[6] * v3[4] * v4[3] * v5[0]) + (-1 * v0[2] * v1[3] * v2[0] * v3[1] * v4[4] * v5[6]) + (v0[2] * v1[3] * v2[0] * v3[1] * v4[6] * v5[4]) + (v0[2] * v1[3] * v2[0] * v3[4] * v4[1] * v5[6]) + (-1 * v0[2] * v1[3] * v2[0] * v3[4] * v4[6] * v5[1]) + (-1 * v0[2] * v1[3] * v2[0] * v3[6] * v4[1] * v5[4]) + (v0[2] * v1[3] * v2[0] * v3[6] * v4[4] * v5[1]) + (v0[2] * v1[3] * v2[1] * v3[0] * v4[4] * v5[6]) + (-1 * v0[2] * v1[3] * v2[1] * v3[0] * v4[6] * v5[4]) + (-1 * v0[2] * v1[3] * v2[1] * v3[4] * v4[0] * v5[6]) + (v0[2] * v1[3] * v2[1] * v3[4] * v4[6] * v5[0]) + (v0[2] * v1[3] * v2[1] * v3[6] * v4[0] * v5[4]) + (-1 * v0[2] * v1[3] * v2[1] * v3[6] * v4[4] * v5[0]) + (-1 * v0[2] * v1[3] * v2[4] * v3[0] * v4[1] * v5[6]) + (v0[2] * v1[3] * v2[4] * v3[0] * v4[6] * v5[1]) + (v0[2] * v1[3] * v2[4] * v3[1] * v4[0] * v5[6]) + (-1 * v0[2] * v1[3] * v2[4] * v3[1] * v4[6] * v5[0]) + (-1 * v0[2] * v1[3] * v2[4] * v3[6] * v4[0] * v5[1]) + (v0[2] * v1[3] * v2[4] * v3[6] * v4[1] * v5[0]) + (v0[2] * v1[3] * v2[6] * v3[0] * v4[1] * v5[4]) + (-1 * v0[2] * v1[3] * v2[6] * v3[0] * v4[4] * v5[1]) + (-1 * v0[2] * v1[3] * v2[6] * v3[1] * v4[0] * v5[4]) + (v0[2] * v1[3] * v2[6] * v3[1] * v4[4] * v5[0]) + (v0[2] * v1[3] * v2[6] * v3[4] * v4[0] * v5[1]) + (-1 * v0[2] * v1[3] * v2[6] * v3[4] * v4[1] * v5[0]) + (v0[2] * v1[4] * v2[0] * v3[1] * v4[3] * v5[6]) + (-1 * v0[2] * v1[4] * v2[0] * v3[1] * v4[6] * v5[3]) + (-1 * v0[2] * v1[4] * v2[0] * v3[3] * v4[1] * v5[6]) + (v0[2] * v1[4] * v2[0] * v3[3] * v4[6] * v5[1]) + (v0[2] * v1[4] * v2[0] * v3[6] * v4[1] * v5[3]) + (-1 * v0[2] * v1[4] * v2[0] * v3[6] * v4[3] * v5[1]) + (-1 * v0[2] * v1[4] * v2[1] * v3[0] * v4[3] * v5[6]) + (v0[2] * v1[4] * v2[1] * v3[0] * v4[6] * v5[3]) + (v0[2] * v1[4] * v2[1] * v3[3] * v4[0] * v5[6]) + (-1 * v0[2] * v1[4] * v2[1] * v3[3] * v4[6] * v5[0]) + (-1 * v0[2] * v1[4] * v2[1] * v3[6] * v4[0] * v5[3]) + (v0[2] * v1[4] * v2[1] * v3[6] * v4[3] * v5[0]) + (v0[2] * v1[4] * v2[3] * v3[0] * v4[1] * v5[6]) + (-1 * v0[2] * v1[4] * v2[3] * v3[0] * v4[6] * v5[1]) + (-1 * v0[2] * v1[4] * v2[3] * v3[1] * v4[0] * v5[6]) + (v0[2] * v1[4] * v2[3] * v3[1] * v4[6] * v5[0]) + (v0[2] * v1[4] * v2[3] * v3[6] * v4[0] * v5[1]) + (-1 * v0[2] * v1[4] * v2[3] * v3[6] * v4[1] * v5[0]) + (-1 * v0[2] * v1[4] * v2[6] * v3[0] * v4[1] * v5[3]) + (v0[2] * v1[4] * v2[6] * v3[0] * v4[3] * v5[1]) + (v0[2] * v1[4] * v2[6] * v3[1] * v4[0] * v5[3]) + (-1 * v0[2] * v1[4] * v2[6] * v3[1] * v4[3] * v5[0]) + (-1 * v0[2] * v1[4] * v2[6] * v3[3] * v4[0] * v5[1]) + (v0[2] * v1[4] * v2[6] * v3[3] * v4[1] * v5[0]) + (-1 * v0[2] * v1[6] * v2[0] * v3[1] * v4[3] * v5[4]) + (v0[2] * v1[6] * v2[0] * v3[1] * v4[4] * v5[3]) + (v0[2] * v1[6] * v2[0] * v3[3] * v4[1] * v5[4]) + (-1 * v0[2] * v1[6] * v2[0] * v3[3] * v4[4] * v5[1]) + (-1 * v0[2] * v1[6] * v2[0] * v3[4] * v4[1] * v5[3]) + (v0[2] * v1[6] * v2[0] * v3[4] * v4[3] * v5[1]) + (v0[2] * v1[6] * v2[1] * v3[0] * v4[3] * v5[4]) + (-1 * v0[2] * v1[6] * v2[1] * v3[0] * v4[4] * v5[3]) + (-1 * v0[2] * v1[6] * v2[1] * v3[3] * v4[0] * v5[4]) + (v0[2] * v1[6] * v2[1] * v3[3] * v4[4] * v5[0]) + (v0[2] * v1[6] * v2[1] * v3[4] * v4[0] * v5[3]) + (-1 * v0[2] * v1[6] * v2[1] * v3[4] * v4[3] * v5[0]) + (-1 * v0[2] * v1[6] * v2[3] * v3[0] * v4[1] * v5[4]) + (v0[2] * v1[6] * v2[3] * v3[0] * v4[4] * v5[1]) + (v0[2] * v1[6] * v2[3] * v3[1] * v4[0] * v5[4]) + (-1 * v0[2] * v1[6] * v2[3] * v3[1] * v4[4] * v5[0]) + (-1 * v0[2] * v1[6] * v2[3] * v3[4] * v4[0] * v5[1]) + (v0[2] * v1[6] * v2[3] * v3[4] * v4[1] * v5[0]) + (v0[2] * v1[6] * v2[4] * v3[0] * v4[1] * v5[3]) + (-1 * v0[2] * v1[6] * v2[4] * v3[0] * v4[3] * v5[1]) + (-1 * v0[2] * v1[6] * v2[4] * v3[1] * v4[0] * v5[3]) + (v0[2] * v1[6] * v2[4] * v3[1] * v4[3] * v5[0]) + (v0[2] * v1[6] * v2[4] * v3[3] * v4[0] * v5[1]) + (-1 * v0[2] * v1[6] * v2[4] * v3[3] * v4[1] * v5[0]) + (v0[3] * v1[0] * v2[1] * v3[2] * v4[4] * v5[6]) + (-1 * v0[3] * v1[0] * v2[1] * v3[2] * v4[6] * v5[4]) + (-1 * v0[3] * v1[0] * v2[1] * v3[4] * v4[2] * v5[6]) + (v0[3] * v1[0] * v2[1] * v3[4] * v4[6] * v5[2]) + (v0[3] * v1[0] * v2[1] * v3[6] * v4[2] * v5[4]) + (-1 * v0[3] * v1[0] * v2[1] * v3[6] * v4[4] * v5[2]) + (-1 * v0[3] * v1[0] * v2[2] * v3[1] * v4[4] * v5[6]) + (v0[3] * v1[0] * v2[2] * v3[1] * v4[6] * v5[4]) + (v0[3] * v1[0] * v2[2] * v3[4] * v4[1] * v5[6]) + (-1 * v0[3] * v1[0] * v2[2] * v3[4] * v4[6] * v5[1]) + (-1 * v0[3] * v1[0] * v2[2] * v3[6] * v4[1] * v5[4]) + (v0[3] * v1[0] * v2[2] * v3[6] * v4[4] * v5[1]) + (v0[3] * v1[0] * v2[4] * v3[1] * v4[2] * v5[6]) + (-1 * v0[3] * v1[0] * v2[4] * v3[1] * v4[6] * v5[2]) + (-1 * v0[3] * v1[0] * v2[4] * v3[2] * v4[1] * v5[6]) + (v0[3] * v1[0] * v2[4] * v3[2] * v4[6] * v5[1]) + (v0[3] * v1[0] * v2[4] * v3[6] * v4[1] * v5[2]) + (-1 * v0[3] * v1[0] * v2[4] * v3[6] * v4[2] * v5[1]) + (-1 * v0[3] * v1[0] * v2[6] * v3[1] * v4[2] * v5[4]) + (v0[3] * v1[0] * v2[6] * v3[1] * v4[4] * v5[2]) + (v0[3] * v1[0] * v2[6] * v3[2] * v4[1] * v5[4]) + (-1 * v0[3] * v1[0] * v2[6] * v3[2] * v4[4] * v5[1]) + (-1 * v0[3] * v1[0] * v2[6] * v3[4] * v4[1] * v5[2]) + (v0[3] * v1[0] * v2[6] * v3[4] * v4[2] * v5[1]) + (-1 * v0[3] * v1[1] * v2[0] * v3[2] * v4[4] * v5[6]) + (v0[3] * v1[1] * v2[0] * v3[2] * v4[6] * v5[4]) + (v0[3] * v1[1] * v2[0] * v3[4] * v4[2] * v5[6]) + (-1 * v0[3] * v1[1] * v2[0] * v3[4] * v4[6] * v5[2]) + (-1 * v0[3] * v1[1] * v2[0] * v3[6] * v4[2] * v5[4]) + (v0[3] * v1[1] * v2[0] * v3[6] * v4[4] * v5[2]) + (v0[3] * v1[1] * v2[2] * v3[0] * v4[4] * v5[6]) + (-1 * v0[3] * v1[1] * v2[2] * v3[0] * v4[6] * v5[4]) + (-1 * v0[3] * v1[1] * v2[2] * v3[4] * v4[0] * v5[6]) + (v0[3] * v1[1] * v2[2] * v3[4] * v4[6] * v5[0]) + (v0[3] * v1[1] * v2[2] * v3[6] * v4[0] * v5[4]) + (-1 * v0[3] * v1[1] * v2[2] * v3[6] * v4[4] * v5[0]) + (-1 * v0[3] * v1[1] * v2[4] * v3[0] * v4[2] * v5[6]) + (v0[3] * v1[1] * v2[4] * v3[0] * v4[6] * v5[2]) + (v0[3] * v1[1] * v2[4] * v3[2] * v4[0] * v5[6]) + (-1 * v0[3] * v1[1] * v2[4] * v3[2] * v4[6] * v5[0]) + (-1 * v0[3] * v1[1] * v2[4] * v3[6] * v4[0] * v5[2]) + (v0[3] * v1[1] * v2[4] * v3[6] * v4[2] * v5[0]) + (v0[3] * v1[1] * v2[6] * v3[0] * v4[2] * v5[4]) + (-1 * v0[3] * v1[1] * v2[6] * v3[0] * v4[4] * v5[2]) + (-1 * v0[3] * v1[1] * v2[6] * v3[2] * v4[0] * v5[4]) + (v0[3] * v1[1] * v2[6] * v3[2] * v4[4] * v5[0]) + (v0[3] * v1[1] * v2[6] * v3[4] * v4[0] * v5[2]) + (-1 * v0[3] * v1[1] * v2[6] * v3[4] * v4[2] * v5[0]) + (v0[3] * v1[2] * v2[0] * v3[1] * v4[4] * v5[6]) + (-1 * v0[3] * v1[2] * v2[0] * v3[1] * v4[6] * v5[4]) + (-1 * v0[3] * v1[2] * v2[0] * v3[4] * v4[1] * v5[6]) + (v0[3] * v1[2] * v2[0] * v3[4] * v4[6] * v5[1]) + (v0[3] * v1[2] * v2[0] * v3[6] * v4[1] * v5[4]) + (-1 * v0[3] * v1[2] * v2[0] * v3[6] * v4[4] * v5[1]) + (-1 * v0[3] * v1[2] * v2[1] * v3[0] * v4[4] * v5[6]) + (v0[3] * v1[2] * v2[1] * v3[0] * v4[6] * v5[4]) + (v0[3] * v1[2] * v2[1] * v3[4] * v4[0] * v5[6]) + (-1 * v0[3] * v1[2] * v2[1] * v3[4] * v4[6] * v5[0]) + (-1 * v0[3] * v1[2] * v2[1] * v3[6] * v4[0] * v5[4]) + (v0[3] * v1[2] * v2[1] * v3[6] * v4[4] * v5[0]) + (v0[3] * v1[2] * v2[4] * v3[0] * v4[1] * v5[6]) + (-1 * v0[3] * v1[2] * v2[4] * v3[0] * v4[6] * v5[1]) + (-1 * v0[3] * v1[2] * v2[4] * v3[1] * v4[0] * v5[6]) + (v0[3] * v1[2] * v2[4] * v3[1] * v4[6] * v5[0]) + (v0[3] * v1[2] * v2[4] * v3[6] * v4[0] * v5[1]) + (-1 * v0[3] * v1[2] * v2[4] * v3[6] * v4[1] * v5[0]) + (-1 * v0[3] * v1[2] * v2[6] * v3[0] * v4[1] * v5[4]) + (v0[3] * v1[2] * v2[6] * v3[0] * v4[4] * v5[1]) + (v0[3] * v1[2] * v2[6] * v3[1] * v4[0] * v5[4]) + (-1 * v0[3] * v1[2] * v2[6] * v3[1] * v4[4] * v5[0]) + (-1 * v0[3] * v1[2] * v2[6] * v3[4] * v4[0] * v5[1]) + (v0[3] * v1[2] * v2[6] * v3[4] * v4[1] * v5[0]) + (-1 * v0[3] * v1[4] * v2[0] * v3[1] * v4[2] * v5[6]) + (v0[3] * v1[4] * v2[0] * v3[1] * v4[6] * v5[2]) + (v0[3] * v1[4] * v2[0] * v3[2] * v4[1] * v5[6]) + (-1 * v0[3] * v1[4] * v2[0] * v3[2] * v4[6] * v5[1]) + (-1 * v0[3] * v1[4] * v2[0] * v3[6] * v4[1] * v5[2]) + (v0[3] * v1[4] * v2[0] * v3[6] * v4[2] * v5[1]) + (v0[3] * v1[4] * v2[1] * v3[0] * v4[2] * v5[6]) + (-1 * v0[3] * v1[4] * v2[1] * v3[0] * v4[6] * v5[2]) + (-1 * v0[3] * v1[4] * v2[1] * v3[2] * v4[0] * v5[6]) + (v0[3] * v1[4] * v2[1] * v3[2] * v4[6] * v5[0]) + (v0[3] * v1[4] * v2[1] * v3[6] * v4[0] * v5[2]) + (-1 * v0[3] * v1[4] * v2[1] * v3[6] * v4[2] * v5[0]) + (-1 * v0[3] * v1[4] * v2[2] * v3[0] * v4[1] * v5[6]) + (v0[3] * v1[4] * v2[2] * v3[0] * v4[6] * v5[1]) + (v0[3] * v1[4] * v2[2] * v3[1] * v4[0] * v5[6]) + (-1 * v0[3] * v1[4] * v2[2] * v3[1] * v4[6] * v5[0]) + (-1 * v0[3] * v1[4] * v2[2] * v3[6] * v4[0] * v5[1]) + (v0[3] * v1[4] * v2[2] * v3[6] * v4[1] * v5[0]) + (v0[3] * v1[4] * v2[6] * v3[0] * v4[1] * v5[2]) + (-1 * v0[3] * v1[4] * v2[6] * v3[0] * v4[2] * v5[1]) + (-1 * v0[3] * v1[4] * v2[6] * v3[1] * v4[0] * v5[2]) + (v0[3] * v1[4] * v2[6] * v3[1] * v4[2] * v5[0]) + (v0[3] * v1[4] * v2[6] * v3[2] * v4[0] * v5[1]) + (-1 * v0[3] * v1[4] * v2[6] * v3[2] * v4[1] * v5[0]) + (v0[3] * v1[6] * v2[0] * v3[1] * v4[2] * v5[4]) + (-1 * v0[3] * v1[6] * v2[0] * v3[1] * v4[4] * v5[2]) + (-1 * v0[3] * v1[6] * v2[0] * v3[2] * v4[1] * v5[4]) + (v0[3] * v1[6] * v2[0] * v3[2] * v4[4] * v5[1]) + (v0[3] * v1[6] * v2[0] * v3[4] * v4[1] * v5[2]) + (-1 * v0[3] * v1[6] * v2[0] * v3[4] * v4[2] * v5[1]) + (-1 * v0[3] * v1[6] * v2[1] * v3[0] * v4[2] * v5[4]) + (v0[3] * v1[6] * v2[1] * v3[0] * v4[4] * v5[2]) + (v0[3] * v1[6] * v2[1] * v3[2] * v4[0] * v5[4]) + (-1 * v0[3] * v1[6] * v2[1] * v3[2] * v4[4] * v5[0]) + (-1 * v0[3] * v1[6] * v2[1] * v3[4] * v4[0] * v5[2]) + (v0[3] * v1[6] * v2[1] * v3[4] * v4[2] * v5[0]) + (v0[3] * v1[6] * v2[2] * v3[0] * v4[1] * v5[4]) + (-1 * v0[3] * v1[6] * v2[2] * v3[0] * v4[4] * v5[1]) + (-1 * v0[3] * v1[6] * v2[2] * v3[1] * v4[0] * v5[4]) + (v0[3] * v1[6] * v2[2] * v3[1] * v4[4] * v5[0]) + (v0[3] * v1[6] * v2[2] * v3[4] * v4[0] * v5[1]) + (-1 * v0[3] * v1[6] * v2[2] * v3[4] * v4[1] * v5[0]) + (-1 * v0[3] * v1[6] * v2[4] * v3[0] * v4[1] * v5[2]) + (v0[3] * v1[6] * v2[4] * v3[0] * v4[2] * v5[1]) + (v0[3] * v1[6] * v2[4] * v3[1] * v4[0] * v5[2]) + (-1 * v0[3] * v1[6] * v2[4] * v3[1] * v4[2] * v5[0]) + (-1 * v0[3] * v1[6] * v2[4] * v3[2] * v4[0] * v5[1]) + (v0[3] * v1[6] * v2[4] * v3[2] * v4[1] * v5[0]) + (-1 * v0[4] * v1[0] * v2[1] * v3[2] * v4[3] * v5[6]) + (v0[4] * v1[0] * v2[1] * v3[2] * v4[6] * v5[3]) + (v0[4] * v1[0] * v2[1] * v3[3] * v4[2] * v5[6]) + (-1 * v0[4] * v1[0] * v2[1] * v3[3] * v4[6] * v5[2]) + (-1 * v0[4] * v1[0] * v2[1] * v3[6] * v4[2] * v5[3]) + (v0[4] * v1[0] * v2[1] * v3[6] * v4[3] * v5[2]) + (v0[4] * v1[0] * v2[2] * v3[1] * v4[3] * v5[6]) + (-1 * v0[4] * v1[0] * v2[2] * v3[1] * v4[6] * v5[3]) + (-1 * v0[4] * v1[0] * v2[2] * v3[3] * v4[1] * v5[6]) + (v0[4] * v1[0] * v2[2] * v3[3] * v4[6] * v5[1]) + (v0[4] * v1[0] * v2[2] * v3[6] * v4[1] * v5[3]) + (-1 * v0[4] * v1[0] * v2[2] * v3[6] * v4[3] * v5[1]) + (-1 * v0[4] * v1[0] * v2[3] * v3[1] * v4[2] * v5[6]) + (v0[4] * v1[0] * v2[3] * v3[1] * v4[6] * v5[2]) + (v0[4] * v1[0] * v2[3] * v3[2] * v4[1] * v5[6]) + (-1 * v0[4] * v1[0] * v2[3] * v3[2] * v4[6] * v5[1]) + (-1 * v0[4] * v1[0] * v2[3] * v3[6] * v4[1] * v5[2]) + (v0[4] * v1[0] * v2[3] * v3[6] * v4[2] * v5[1]) + (v0[4] * v1[0] * v2[6] * v3[1] * v4[2] * v5[3]) + (-1 * v0[4] * v1[0] * v2[6] * v3[1] * v4[3] * v5[2]) + (-1 * v0[4] * v1[0] * v2[6] * v3[2] * v4[1] * v5[3]) + (v0[4] * v1[0] * v2[6] * v3[2] * v4[3] * v5[1]) + (v0[4] * v1[0] * v2[6] * v3[3] * v4[1] * v5[2]) + (-1 * v0[4] * v1[0] * v2[6] * v3[3] * v4[2] * v5[1]) + (v0[4] * v1[1] * v2[0] * v3[2] * v4[3] * v5[6]) + (-1 * v0[4] * v1[1] * v2[0] * v3[2] * v4[6] * v5[3]) + (-1 * v0[4] * v1[1] * v2[0] * v3[3] * v4[2] * v5[6]) + (v0[4] * v1[1] * v2[0] * v3[3] * v4[6] * v5[2]) + (v0[4] * v1[1] * v2[0] * v3[6] * v4[2] * v5[3]) + (-1 * v0[4] * v1[1] * v2[0] * v3[6] * v4[3] * v5[2]) + (-1 * v0[4] * v1[1] * v2[2] * v3[0] * v4[3] * v5[6]) + (v0[4] * v1[1] * v2[2] * v3[0] * v4[6] * v5[3]) + (v0[4] * v1[1] * v2[2] * v3[3] * v4[0] * v5[6]) + (-1 * v0[4] * v1[1] * v2[2] * v3[3] * v4[6] * v5[0]) + (-1 * v0[4] * v1[1] * v2[2] * v3[6] * v4[0] * v5[3]) + (v0[4] * v1[1] * v2[2] * v3[6] * v4[3] * v5[0]) + (v0[4] * v1[1] * v2[3] * v3[0] * v4[2] * v5[6]) + (-1 * v0[4] * v1[1] * v2[3] * v3[0] * v4[6] * v5[2]) + (-1 * v0[4] * v1[1] * v2[3] * v3[2] * v4[0] * v5[6]) + (v0[4] * v1[1] * v2[3] * v3[2] * v4[6] * v5[0]) + (v0[4] * v1[1] * v2[3] * v3[6] * v4[0] * v5[2]) + (-1 * v0[4] * v1[1] * v2[3] * v3[6] * v4[2] * v5[0]) + (-1 * v0[4] * v1[1] * v2[6] * v3[0] * v4[2] * v5[3]) + (v0[4] * v1[1] * v2[6] * v3[0] * v4[3] * v5[2]) + (v0[4] * v1[1] * v2[6] * v3[2] * v4[0] * v5[3]) + (-1 * v0[4] * v1[1] * v2[6] * v3[2] * v4[3] * v5[0]) + (-1 * v0[4] * v1[1] * v2[6] * v3[3] * v4[0] * v5[2]) + (v0[4] * v1[1] * v2[6] * v3[3] * v4[2] * v5[0]) + (-1 * v0[4] * v1[2] * v2[0] * v3[1] * v4[3] * v5[6]) + (v0[4] * v1[2] * v2[0] * v3[1] * v4[6] * v5[3]) + (v0[4] * v1[2] * v2[0] * v3[3] * v4[1] * v5[6]) + (-1 * v0[4] * v1[2] * v2[0] * v3[3] * v4[6] * v5[1]) + (-1 * v0[4] * v1[2] * v2[0] * v3[6] * v4[1] * v5[3]) + (v0[4] * v1[2] * v2[0] * v3[6] * v4[3] * v5[1]) + (v0[4] * v1[2] * v2[1] * v3[0] * v4[3] * v5[6]) + (-1 * v0[4] * v1[2] * v2[1] * v3[0] * v4[6] * v5[3]) + (-1 * v0[4] * v1[2] * v2[1] * v3[3] * v4[0] * v5[6]) + (v0[4] * v1[2] * v2[1] * v3[3] * v4[6] * v5[0]) + (v0[4] * v1[2] * v2[1] * v3[6] * v4[0] * v5[3]) + (-1 * v0[4] * v1[2] * v2[1] * v3[6] * v4[3] * v5[0]) + (-1 * v0[4] * v1[2] * v2[3] * v3[0] * v4[1] * v5[6]) + (v0[4] * v1[2] * v2[3] * v3[0] * v4[6] * v5[1]) + (v0[4] * v1[2] * v2[3] * v3[1] * v4[0] * v5[6]) + (-1 * v0[4] * v1[2] * v2[3] * v3[1] * v4[6] * v5[0]) + (-1 * v0[4] * v1[2] * v2[3] * v3[6] * v4[0] * v5[1]) + (v0[4] * v1[2] * v2[3] * v3[6] * v4[1] * v5[0]) + (v0[4] * v1[2] * v2[6] * v3[0] * v4[1] * v5[3]) + (-1 * v0[4] * v1[2] * v2[6] * v3[0] * v4[3] * v5[1]) + (-1 * v0[4] * v1[2] * v2[6] * v3[1] * v4[0] * v5[3]) + (v0[4] * v1[2] * v2[6] * v3[1] * v4[3] * v5[0]) + (v0[4] * v1[2] * v2[6] * v3[3] * v4[0] * v5[1]) + (-1 * v0[4] * v1[2] * v2[6] * v3[3] * v4[1] * v5[0]) + (v0[4] * v1[3] * v2[0] * v3[1] * v4[2] * v5[6]) + (-1 * v0[4] * v1[3] * v2[0] * v3[1] * v4[6] * v5[2]) + (-1 * v0[4] * v1[3] * v2[0] * v3[2] * v4[1] * v5[6]) + (v0[4] * v1[3] * v2[0] * v3[2] * v4[6] * v5[1]) + (v0[4] * v1[3] * v2[0] * v3[6] * v4[1] * v5[2]) + (-1 * v0[4] * v1[3] * v2[0] * v3[6] * v4[2] * v5[1]) + (-1 * v0[4] * v1[3] * v2[1] * v3[0] * v4[2] * v5[6]) + (v0[4] * v1[3] * v2[1] * v3[0] * v4[6] * v5[2]) + (v0[4] * v1[3] * v2[1] * v3[2] * v4[0] * v5[6]) + (-1 * v0[4] * v1[3] * v2[1] * v3[2] * v4[6] * v5[0]) + (-1 * v0[4] * v1[3] * v2[1] * v3[6] * v4[0] * v5[2]) + (v0[4] * v1[3] * v2[1] * v3[6] * v4[2] * v5[0]) + (v0[4] * v1[3] * v2[2] * v3[0] * v4[1] * v5[6]) + (-1 * v0[4] * v1[3] * v2[2] * v3[0] * v4[6] * v5[1]) + (-1 * v0[4] * v1[3] * v2[2] * v3[1] * v4[0] * v5[6]) + (v0[4] * v1[3] * v2[2] * v3[1] * v4[6] * v5[0]) + (v0[4] * v1[3] * v2[2] * v3[6] * v4[0] * v5[1]) + (-1 * v0[4] * v1[3] * v2[2] * v3[6] * v4[1] * v5[0]) + (-1 * v0[4] * v1[3] * v2[6] * v3[0] * v4[1] * v5[2]) + (v0[4] * v1[3] * v2[6] * v3[0] * v4[2] * v5[1]) + (v0[4] * v1[3] * v2[6] * v3[1] * v4[0] * v5[2]) + (-1 * v0[4] * v1[3] * v2[6] * v3[1] * v4[2] * v5[0]) + (-1 * v0[4] * v1[3] * v2[6] * v3[2] * v4[0] * v5[1]) + (v0[4] * v1[3] * v2[6] * v3[2] * v4[1] * v5[0]) + (-1 * v0[4] * v1[6] * v2[0] * v3[1] * v4[2] * v5[3]) + (v0[4] * v1[6] * v2[0] * v3[1] * v4[3] * v5[2]) + (v0[4] * v1[6] * v2[0] * v3[2] * v4[1] * v5[3]) + (-1 * v0[4] * v1[6] * v2[0] * v3[2] * v4[3] * v5[1]) + (-1 * v0[4] * v1[6] * v2[0] * v3[3] * v4[1] * v5[2]) + (v0[4] * v1[6] * v2[0] * v3[3] * v4[2] * v5[1]) + (v0[4] * v1[6] * v2[1] * v3[0] * v4[2] * v5[3]) + (-1 * v0[4] * v1[6] * v2[1] * v3[0] * v4[3] * v5[2]) + (-1 * v0[4] * v1[6] * v2[1] * v3[2] * v4[0] * v5[3]) + (v0[4] * v1[6] * v2[1] * v3[2] * v4[3] * v5[0]) + (v0[4] * v1[6] * v2[1] * v3[3] * v4[0] * v5[2]) + (-1 * v0[4] * v1[6] * v2[1] * v3[3] * v4[2] * v5[0]) + (-1 * v0[4] * v1[6] * v2[2] * v3[0] * v4[1] * v5[3]) + (v0[4] * v1[6] * v2[2] * v3[0] * v4[3] * v5[1]) + (v0[4] * v1[6] * v2[2] * v3[1] * v4[0] * v5[3]) + (-1 * v0[4] * v1[6] * v2[2] * v3[1] * v4[3] * v5[0]) + (-1 * v0[4] * v1[6] * v2[2] * v3[3] * v4[0] * v5[1]) + (v0[4] * v1[6] * v2[2] * v3[3] * v4[1] * v5[0]) + (v0[4] * v1[6] * v2[3] * v3[0] * v4[1] * v5[2]) + (-1 * v0[4] * v1[6] * v2[3] * v3[0] * v4[2] * v5[1]) + (-1 * v0[4] * v1[6] * v2[3] * v3[1] * v4[0] * v5[2]) + (v0[4] * v1[6] * v2[3] * v3[1] * v4[2] * v5[0]) + (v0[4] * v1[6] * v2[3] * v3[2] * v4[0] * v5[1]) + (-1 * v0[4] * v1[6] * v2[3] * v3[2] * v4[1] * v5[0]) + (v0[6] * v1[0] * v2[1] * v3[2] * v4[3] * v5[4]) + (-1 * v0[6] * v1[0] * v2[1] * v3[2] * v4[4] * v5[3]) + (-1 * v0[6] * v1[0] * v2[1] * v3[3] * v4[2] * v5[4]) + (v0[6] * v1[0] * v2[1] * v3[3] * v4[4] * v5[2]) + (v0[6] * v1[0] * v2[1] * v3[4] * v4[2] * v5[3]) + (-1 * v0[6] * v1[0] * v2[1] * v3[4] * v4[3] * v5[2]) + (-1 * v0[6] * v1[0] * v2[2] * v3[1] * v4[3] * v5[4]) + (v0[6] * v1[0] * v2[2] * v3[1] * v4[4] * v5[3]) + (v0[6] * v1[0] * v2[2] * v3[3] * v4[1] * v5[4]) + (-1 * v0[6] * v1[0] * v2[2] * v3[3] * v4[4] * v5[1]) + (-1 * v0[6] * v1[0] * v2[2] * v3[4] * v4[1] * v5[3]) + (v0[6] * v1[0] * v2[2] * v3[4] * v4[3] * v5[1]) + (v0[6] * v1[0] * v2[3] * v3[1] * v4[2] * v5[4]) + (-1 * v0[6] * v1[0] * v2[3] * v3[1] * v4[4] * v5[2]) + (-1 * v0[6] * v1[0] * v2[3] * v3[2] * v4[1] * v5[4]) + (v0[6] * v1[0] * v2[3] * v3[2] * v4[4] * v5[1]) + (v0[6] * v1[0] * v2[3] * v3[4] * v4[1] * v5[2]) + (-1 * v0[6] * v1[0] * v2[3] * v3[4] * v4[2] * v5[1]) + (-1 * v0[6] * v1[0] * v2[4] * v3[1] * v4[2] * v5[3]) + (v0[6] * v1[0] * v2[4] * v3[1] * v4[3] * v5[2]) + (v0[6] * v1[0] * v2[4] * v3[2] * v4[1] * v5[3]) + (-1 * v0[6] * v1[0] * v2[4] * v3[2] * v4[3] * v5[1]) + (-1 * v0[6] * v1[0] * v2[4] * v3[3] * v4[1] * v5[2]) + (v0[6] * v1[0] * v2[4] * v3[3] * v4[2] * v5[1]) + (-1 * v0[6] * v1[1] * v2[0] * v3[2] * v4[3] * v5[4]) + (v0[6] * v1[1] * v2[0] * v3[2] * v4[4] * v5[3]) + (v0[6] * v1[1] * v2[0] * v3[3] * v4[2] * v5[4]) + (-1 * v0[6] * v1[1] * v2[0] * v3[3] * v4[4] * v5[2]) + (-1 * v0[6] * v1[1] * v2[0] * v3[4] * v4[2] * v5[3]) + (v0[6] * v1[1] * v2[0] * v3[4] * v4[3] * v5[2]) + (v0[6] * v1[1] * v2[2] * v3[0] * v4[3] * v5[4]) + (-1 * v0[6] * v1[1] * v2[2] * v3[0] * v4[4] * v5[3]) + (-1 * v0[6] * v1[1] * v2[2] * v3[3] * v4[0] * v5[4]) + (v0[6] * v1[1] * v2[2] * v3[3] * v4[4] * v5[0]) + (v0[6] * v1[1] * v2[2] * v3[4] * v4[0] * v5[3]) + (-1 * v0[6] * v1[1] * v2[2] * v3[4] * v4[3] * v5[0]) + (-1 * v0[6] * v1[1] * v2[3] * v3[0] * v4[2] * v5[4]) + (v0[6] * v1[1] * v2[3] * v3[0] * v4[4] * v5[2]) + (v0[6] * v1[1] * v2[3] * v3[2] * v4[0] * v5[4]) + (-1 * v0[6] * v1[1] * v2[3] * v3[2] * v4[4] * v5[0]) + (-1 * v0[6] * v1[1] * v2[3] * v3[4] * v4[0] * v5[2]) + (v0[6] * v1[1] * v2[3] * v3[4] * v4[2] * v5[0]) + (v0[6] * v1[1] * v2[4] * v3[0] * v4[2] * v5[3]) + (-1 * v0[6] * v1[1] * v2[4] * v3[0] * v4[3] * v5[2]) + (-1 * v0[6] * v1[1] * v2[4] * v3[2] * v4[0] * v5[3]) + (v0[6] * v1[1] * v2[4] * v3[2] * v4[3] * v5[0]) + (v0[6] * v1[1] * v2[4] * v3[3] * v4[0] * v5[2]) + (-1 * v0[6] * v1[1] * v2[4] * v3[3] * v4[2] * v5[0]) + (v0[6] * v1[2] * v2[0] * v3[1] * v4[3] * v5[4]) + (-1 * v0[6] * v1[2] * v2[0] * v3[1] * v4[4] * v5[3]) + (-1 * v0[6] * v1[2] * v2[0] * v3[3] * v4[1] * v5[4]) + (v0[6] * v1[2] * v2[0] * v3[3] * v4[4] * v5[1]) + (v0[6] * v1[2] * v2[0] * v3[4] * v4[1] * v5[3]) + (-1 * v0[6] * v1[2] * v2[0] * v3[4] * v4[3] * v5[1]) + (-1 * v0[6] * v1[2] * v2[1] * v3[0] * v4[3] * v5[4]) + (v0[6] * v1[2] * v2[1] * v3[0] * v4[4] * v5[3]) + (v0[6] * v1[2] * v2[1] * v3[3] * v4[0] * v5[4]) + (-1 * v0[6] * v1[2] * v2[1] * v3[3] * v4[4] * v5[0]) + (-1 * v0[6] * v1[2] * v2[1] * v3[4] * v4[0] * v5[3]) + (v0[6] * v1[2] * v2[1] * v3[4] * v4[3] * v5[0]) + (v0[6] * v1[2] * v2[3] * v3[0] * v4[1] * v5[4]) + (-1 * v0[6] * v1[2] * v2[3] * v3[0] * v4[4] * v5[1]) + (-1 * v0[6] * v1[2] * v2[3] * v3[1] * v4[0] * v5[4]) + (v0[6] * v1[2] * v2[3] * v3[1] * v4[4] * v5[0]) + (v0[6] * v1[2] * v2[3] * v3[4] * v4[0] * v5[1]) + (-1 * v0[6] * v1[2] * v2[3] * v3[4] * v4[1] * v5[0]) + (-1 * v0[6] * v1[2] * v2[4] * v3[0] * v4[1] * v5[3]) + (v0[6] * v1[2] * v2[4] * v3[0] * v4[3] * v5[1]) + (v0[6] * v1[2] * v2[4] * v3[1] * v4[0] * v5[3]) + (-1 * v0[6] * v1[2] * v2[4] * v3[1] * v4[3] * v5[0]) + (-1 * v0[6] * v1[2] * v2[4] * v3[3] * v4[0] * v5[1]) + (v0[6] * v1[2] * v2[4] * v3[3] * v4[1] * v5[0]) + (-1 * v0[6] * v1[3] * v2[0] * v3[1] * v4[2] * v5[4]) + (v0[6] * v1[3] * v2[0] * v3[1] * v4[4] * v5[2]) + (v0[6] * v1[3] * v2[0] * v3[2] * v4[1] * v5[4]) + (-1 * v0[6] * v1[3] * v2[0] * v3[2] * v4[4] * v5[1]) + (-1 * v0[6] * v1[3] * v2[0] * v3[4] * v4[1] * v5[2]) + (v0[6] * v1[3] * v2[0] * v3[4] * v4[2] * v5[1]) + (v0[6] * v1[3] * v2[1] * v3[0] * v4[2] * v5[4]) + (-1 * v0[6] * v1[3] * v2[1] * v3[0] * v4[4] * v5[2]) + (-1 * v0[6] * v1[3] * v2[1] * v3[2] * v4[0] * v5[4]) + (v0[6] * v1[3] * v2[1] * v3[2] * v4[4] * v5[0]) + (v0[6] * v1[3] * v2[1] * v3[4] * v4[0] * v5[2]) + (-1 * v0[6] * v1[3] * v2[1] * v3[4] * v4[2] * v5[0]) + (-1 * v0[6] * v1[3] * v2[2] * v3[0] * v4[1] * v5[4]) + (v0[6] * v1[3] * v2[2] * v3[0] * v4[4] * v5[1]) + (v0[6] * v1[3] * v2[2] * v3[1] * v4[0] * v5[4]) + (-1 * v0[6] * v1[3] * v2[2] * v3[1] * v4[4] * v5[0]) + (-1 * v0[6] * v1[3] * v2[2] * v3[4] * v4[0] * v5[1]) + (v0[6] * v1[3] * v2[2] * v3[4] * v4[1] * v5[0]) + (v0[6] * v1[3] * v2[4] * v3[0] * v4[1] * v5[2]) + (-1 * v0[6] * v1[3] * v2[4] * v3[0] * v4[2] * v5[1]) + (-1 * v0[6] * v1[3] * v2[4] * v3[1] * v4[0] * v5[2]) + (v0[6] * v1[3] * v2[4] * v3[1] * v4[2] * v5[0]) + (v0[6] * v1[3] * v2[4] * v3[2] * v4[0] * v5[1]) + (-1 * v0[6] * v1[3] * v2[4] * v3[2] * v4[1] * v5[0]) + (v0[6] * v1[4] * v2[0] * v3[1] * v4[2] * v5[3]) + (-1 * v0[6] * v1[4] * v2[0] * v3[1] * v4[3] * v5[2]) + (-1 * v0[6] * v1[4] * v2[0] * v3[2] * v4[1] * v5[3]) + (v0[6] * v1[4] * v2[0] * v3[2] * v4[3] * v5[1]) + (v0[6] * v1[4] * v2[0] * v3[3] * v4[1] * v5[2]) + (-1 * v0[6] * v1[4] * v2[0] * v3[3] * v4[2] * v5[1]) + (-1 * v0[6] * v1[4] * v2[1] * v3[0] * v4[2] * v5[3]) + (v0[6] * v1[4] * v2[1] * v3[0] * v4[3] * v5[2]) + (v0[6] * v1[4] * v2[1] * v3[2] * v4[0] * v5[3]) + (-1 * v0[6] * v1[4] * v2[1] * v3[2] * v4[3] * v5[0]) + (-1 * v0[6] * v1[4] * v2[1] * v3[3] * v4[0] * v5[2]) + (v0[6] * v1[4] * v2[1] * v3[3] * v4[2] * v5[0]) + (v0[6] * v1[4] * v2[2] * v3[0] * v4[1] * v5[3]) + (-1 * v0[6] * v1[4] * v2[2] * v3[0] * v4[3] * v5[1]) + (-1 * v0[6] * v1[4] * v2[2] * v3[1] * v4[0] * v5[3]) + (v0[6] * v1[4] * v2[2] * v3[1] * v4[3] * v5[0]) + (v0[6] * v1[4] * v2[2] * v3[3] * v4[0] * v5[1]) + (-1 * v0[6] * v1[4] * v2[2] * v3[3] * v4[1] * v5[0]) + (-1 * v0[6] * v1[4] * v2[3] * v3[0] * v4[1] * v5[2]) + (v0[6] * v1[4] * v2[3] * v3[0] * v4[2] * v5[1]) + (v0[6] * v1[4] * v2[3] * v3[1] * v4[0] * v5[2]) + (-1 * v0[6] * v1[4] * v2[3] * v3[1] * v4[2] * v5[0]) + (-1 * v0[6] * v1[4] * v2[3] * v3[2] * v4[0] * v5[1]) + (v0[6] * v1[4] * v2[3] * v3[2] * v4[1] * v5[0]);
r0[6] = (v0[0] * v1[1] * v2[2] * v3[3] * v4[4] * v5[5]) + (-1 * v0[0] * v1[1] * v2[2] * v3[3] * v4[5] * v5[4]) + (-1 * v0[0] * v1[1] * v2[2] * v3[4] * v4[3] * v5[5]) + (v0[0] * v1[1] * v2[2] * v3[4] * v4[5] * v5[3]) + (v0[0] * v1[1] * v2[2] * v3[5] * v4[3] * v5[4]) + (-1 * v0[0] * v1[1] * v2[2] * v3[5] * v4[4] * v5[3]) + (-1 * v0[0] * v1[1] * v2[3] * v3[2] * v4[4] * v5[5]) + (v0[0] * v1[1] * v2[3] * v3[2] * v4[5] * v5[4]) + (v0[0] * v1[1] * v2[3] * v3[4] * v4[2] * v5[5]) + (-1 * v0[0] * v1[1] * v2[3] * v3[4] * v4[5] * v5[2]) + (-1 * v0[0] * v1[1] * v2[3] * v3[5] * v4[2] * v5[4]) + (v0[0] * v1[1] * v2[3] * v3[5] * v4[4] * v5[2]) + (v0[0] * v1[1] * v2[4] * v3[2] * v4[3] * v5[5]) + (-1 * v0[0] * v1[1] * v2[4] * v3[2] * v4[5] * v5[3]) + (-1 * v0[0] * v1[1] * v2[4] * v3[3] * v4[2] * v5[5]) + (v0[0] * v1[1] * v2[4] * v3[3] * v4[5] * v5[2]) + (v0[0] * v1[1] * v2[4] * v3[5] * v4[2] * v5[3]) + (-1 * v0[0] * v1[1] * v2[4] * v3[5] * v4[3] * v5[2]) + (-1 * v0[0] * v1[1] * v2[5] * v3[2] * v4[3] * v5[4]) + (v0[0] * v1[1] * v2[5] * v3[2] * v4[4] * v5[3]) + (v0[0] * v1[1] * v2[5] * v3[3] * v4[2] * v5[4]) + (-1 * v0[0] * v1[1] * v2[5] * v3[3] * v4[4] * v5[2]) + (-1 * v0[0] * v1[1] * v2[5] * v3[4] * v4[2] * v5[3]) + (v0[0] * v1[1] * v2[5] * v3[4] * v4[3] * v5[2]) + (-1 * v0[0] * v1[2] * v2[1] * v3[3] * v4[4] * v5[5]) + (v0[0] * v1[2] * v2[1] * v3[3] * v4[5] * v5[4]) + (v0[0] * v1[2] * v2[1] * v3[4] * v4[3] * v5[5]) + (-1 * v0[0] * v1[2] * v2[1] * v3[4] * v4[5] * v5[3]) + (-1 * v0[0] * v1[2] * v2[1] * v3[5] * v4[3] * v5[4]) + (v0[0] * v1[2] * v2[1] * v3[5] * v4[4] * v5[3]) + (v0[0] * v1[2] * v2[3] * v3[1] * v4[4] * v5[5]) + (-1 * v0[0] * v1[2] * v2[3] * v3[1] * v4[5] * v5[4]) + (-1 * v0[0] * v1[2] * v2[3] * v3[4] * v4[1] * v5[5]) + (v0[0] * v1[2] * v2[3] * v3[4] * v4[5] * v5[1]) + (v0[0] * v1[2] * v2[3] * v3[5] * v4[1] * v5[4]) + (-1 * v0[0] * v1[2] * v2[3] * v3[5] * v4[4] * v5[1]) + (-1 * v0[0] * v1[2] * v2[4] * v3[1] * v4[3] * v5[5]) + (v0[0] * v1[2] * v2[4] * v3[1] * v4[5] * v5[3]) + (v0[0] * v1[2] * v2[4] * v3[3] * v4[1] * v5[5]) + (-1 * v0[0] * v1[2] * v2[4] * v3[3] * v4[5] * v5[1]) + (-1 * v0[0] * v1[2] * v2[4] * v3[5] * v4[1] * v5[3]) + (v0[0] * v1[2] * v2[4] * v3[5] * v4[3] * v5[1]) + (v0[0] * v1[2] * v2[5] * v3[1] * v4[3] * v5[4]) + (-1 * v0[0] * v1[2] * v2[5] * v3[1] * v4[4] * v5[3]) + (-1 * v0[0] * v1[2] * v2[5] * v3[3] * v4[1] * v5[4]) + (v0[0] * v1[2] * v2[5] * v3[3] * v4[4] * v5[1]) + (v0[0] * v1[2] * v2[5] * v3[4] * v4[1] * v5[3]) + (-1 * v0[0] * v1[2] * v2[5] * v3[4] * v4[3] * v5[1]) + (v0[0] * v1[3] * v2[1] * v3[2] * v4[4] * v5[5]) + (-1 * v0[0] * v1[3] * v2[1] * v3[2] * v4[5] * v5[4]) + (-1 * v0[0] * v1[3] * v2[1] * v3[4] * v4[2] * v5[5]) + (v0[0] * v1[3] * v2[1] * v3[4] * v4[5] * v5[2]) + (v0[0] * v1[3] * v2[1] * v3[5] * v4[2] * v5[4]) + (-1 * v0[0] * v1[3] * v2[1] * v3[5] * v4[4] * v5[2]) + (-1 * v0[0] * v1[3] * v2[2] * v3[1] * v4[4] * v5[5]) + (v0[0] * v1[3] * v2[2] * v3[1] * v4[5] * v5[4]) + (v0[0] * v1[3] * v2[2] * v3[4] * v4[1] * v5[5]) + (-1 * v0[0] * v1[3] * v2[2] * v3[4] * v4[5] * v5[1]) + (-1 * v0[0] * v1[3] * v2[2] * v3[5] * v4[1] * v5[4]) + (v0[0] * v1[3] * v2[2] * v3[5] * v4[4] * v5[1]) + (v0[0] * v1[3] * v2[4] * v3[1] * v4[2] * v5[5]) + (-1 * v0[0] * v1[3] * v2[4] * v3[1] * v4[5] * v5[2]) + (-1 * v0[0] * v1[3] * v2[4] * v3[2] * v4[1] * v5[5]) + (v0[0] * v1[3] * v2[4] * v3[2] * v4[5] * v5[1]) + (v0[0] * v1[3] * v2[4] * v3[5] * v4[1] * v5[2]) + (-1 * v0[0] * v1[3] * v2[4] * v3[5] * v4[2] * v5[1]) + (-1 * v0[0] * v1[3] * v2[5] * v3[1] * v4[2] * v5[4]) + (v0[0] * v1[3] * v2[5] * v3[1] * v4[4] * v5[2]) + (v0[0] * v1[3] * v2[5] * v3[2] * v4[1] * v5[4]) + (-1 * v0[0] * v1[3] * v2[5] * v3[2] * v4[4] * v5[1]) + (-1 * v0[0] * v1[3] * v2[5] * v3[4] * v4[1] * v5[2]) + (v0[0] * v1[3] * v2[5] * v3[4] * v4[2] * v5[1]) + (-1 * v0[0] * v1[4] * v2[1] * v3[2] * v4[3] * v5[5]) + (v0[0] * v1[4] * v2[1] * v3[2] * v4[5] * v5[3]) + (v0[0] * v1[4] * v2[1] * v3[3] * v4[2] * v5[5]) + (-1 * v0[0] * v1[4] * v2[1] * v3[3] * v4[5] * v5[2]) + (-1 * v0[0] * v1[4] * v2[1] * v3[5] * v4[2] * v5[3]) + (v0[0] * v1[4] * v2[1] * v3[5] * v4[3] * v5[2]) + (v0[0] * v1[4] * v2[2] * v3[1] * v4[3] * v5[5]) + (-1 * v0[0] * v1[4] * v2[2] * v3[1] * v4[5] * v5[3]) + (-1 * v0[0] * v1[4] * v2[2] * v3[3] * v4[1] * v5[5]) + (v0[0] * v1[4] * v2[2] * v3[3] * v4[5] * v5[1]) + (v0[0] * v1[4] * v2[2] * v3[5] * v4[1] * v5[3]) + (-1 * v0[0] * v1[4] * v2[2] * v3[5] * v4[3] * v5[1]) + (-1 * v0[0] * v1[4] * v2[3] * v3[1] * v4[2] * v5[5]) + (v0[0] * v1[4] * v2[3] * v3[1] * v4[5] * v5[2]) + (v0[0] * v1[4] * v2[3] * v3[2] * v4[1] * v5[5]) + (-1 * v0[0] * v1[4] * v2[3] * v3[2] * v4[5] * v5[1]) + (-1 * v0[0] * v1[4] * v2[3] * v3[5] * v4[1] * v5[2]) + (v0[0] * v1[4] * v2[3] * v3[5] * v4[2] * v5[1]) + (v0[0] * v1[4] * v2[5] * v3[1] * v4[2] * v5[3]) + (-1 * v0[0] * v1[4] * v2[5] * v3[1] * v4[3] * v5[2]) + (-1 * v0[0] * v1[4] * v2[5] * v3[2] * v4[1] * v5[3]) + (v0[0] * v1[4] * v2[5] * v3[2] * v4[3] * v5[1]) + (v0[0] * v1[4] * v2[5] * v3[3] * v4[1] * v5[2]) + (-1 * v0[0] * v1[4] * v2[5] * v3[3] * v4[2] * v5[1]) + (v0[0] * v1[5] * v2[1] * v3[2] * v4[3] * v5[4]) + (-1 * v0[0] * v1[5] * v2[1] * v3[2] * v4[4] * v5[3]) + (-1 * v0[0] * v1[5] * v2[1] * v3[3] * v4[2] * v5[4]) + (v0[0] * v1[5] * v2[1] * v3[3] * v4[4] * v5[2]) + (v0[0] * v1[5] * v2[1] * v3[4] * v4[2] * v5[3]) + (-1 * v0[0] * v1[5] * v2[1] * v3[4] * v4[3] * v5[2]) + (-1 * v0[0] * v1[5] * v2[2] * v3[1] * v4[3] * v5[4]) + (v0[0] * v1[5] * v2[2] * v3[1] * v4[4] * v5[3]) + (v0[0] * v1[5] * v2[2] * v3[3] * v4[1] * v5[4]) + (-1 * v0[0] * v1[5] * v2[2] * v3[3] * v4[4] * v5[1]) + (-1 * v0[0] * v1[5] * v2[2] * v3[4] * v4[1] * v5[3]) + (v0[0] * v1[5] * v2[2] * v3[4] * v4[3] * v5[1]) + (v0[0] * v1[5] * v2[3] * v3[1] * v4[2] * v5[4]) + (-1 * v0[0] * v1[5] * v2[3] * v3[1] * v4[4] * v5[2]) + (-1 * v0[0] * v1[5] * v2[3] * v3[2] * v4[1] * v5[4]) + (v0[0] * v1[5] * v2[3] * v3[2] * v4[4] * v5[1]) + (v0[0] * v1[5] * v2[3] * v3[4] * v4[1] * v5[2]) + (-1 * v0[0] * v1[5] * v2[3] * v3[4] * v4[2] * v5[1]) + (-1 * v0[0] * v1[5] * v2[4] * v3[1] * v4[2] * v5[3]) + (v0[0] * v1[5] * v2[4] * v3[1] * v4[3] * v5[2]) + (v0[0] * v1[5] * v2[4] * v3[2] * v4[1] * v5[3]) + (-1 * v0[0] * v1[5] * v2[4] * v3[2] * v4[3] * v5[1]) + (-1 * v0[0] * v1[5] * v2[4] * v3[3] * v4[1] * v5[2]) + (v0[0] * v1[5] * v2[4] * v3[3] * v4[2] * v5[1]) + (-1 * v0[1] * v1[0] * v2[2] * v3[3] * v4[4] * v5[5]) + (v0[1] * v1[0] * v2[2] * v3[3] * v4[5] * v5[4]) + (v0[1] * v1[0] * v2[2] * v3[4] * v4[3] * v5[5]) + (-1 * v0[1] * v1[0] * v2[2] * v3[4] * v4[5] * v5[3]) + (-1 * v0[1] * v1[0] * v2[2] * v3[5] * v4[3] * v5[4]) + (v0[1] * v1[0] * v2[2] * v3[5] * v4[4] * v5[3]) + (v0[1] * v1[0] * v2[3] * v3[2] * v4[4] * v5[5]) + (-1 * v0[1] * v1[0] * v2[3] * v3[2] * v4[5] * v5[4]) + (-1 * v0[1] * v1[0] * v2[3] * v3[4] * v4[2] * v5[5]) + (v0[1] * v1[0] * v2[3] * v3[4] * v4[5] * v5[2]) + (v0[1] * v1[0] * v2[3] * v3[5] * v4[2] * v5[4]) + (-1 * v0[1] * v1[0] * v2[3] * v3[5] * v4[4] * v5[2]) + (-1 * v0[1] * v1[0] * v2[4] * v3[2] * v4[3] * v5[5]) + (v0[1] * v1[0] * v2[4] * v3[2] * v4[5] * v5[3]) + (v0[1] * v1[0] * v2[4] * v3[3] * v4[2] * v5[5]) + (-1 * v0[1] * v1[0] * v2[4] * v3[3] * v4[5] * v5[2]) + (-1 * v0[1] * v1[0] * v2[4] * v3[5] * v4[2] * v5[3]) + (v0[1] * v1[0] * v2[4] * v3[5] * v4[3] * v5[2]) + (v0[1] * v1[0] * v2[5] * v3[2] * v4[3] * v5[4]) + (-1 * v0[1] * v1[0] * v2[5] * v3[2] * v4[4] * v5[3]) + (-1 * v0[1] * v1[0] * v2[5] * v3[3] * v4[2] * v5[4]) + (v0[1] * v1[0] * v2[5] * v3[3] * v4[4] * v5[2]) + (v0[1] * v1[0] * v2[5] * v3[4] * v4[2] * v5[3]) + (-1 * v0[1] * v1[0] * v2[5] * v3[4] * v4[3] * v5[2]) + (v0[1] * v1[2] * v2[0] * v3[3] * v4[4] * v5[5]) + (-1 * v0[1] * v1[2] * v2[0] * v3[3] * v4[5] * v5[4]) + (-1 * v0[1] * v1[2] * v2[0] * v3[4] * v4[3] * v5[5]) + (v0[1] * v1[2] * v2[0] * v3[4] * v4[5] * v5[3]) + (v0[1] * v1[2] * v2[0] * v3[5] * v4[3] * v5[4]) + (-1 * v0[1] * v1[2] * v2[0] * v3[5] * v4[4] * v5[3]) + (-1 * v0[1] * v1[2] * v2[3] * v3[0] * v4[4] * v5[5]) + (v0[1] * v1[2] * v2[3] * v3[0] * v4[5] * v5[4]) + (v0[1] * v1[2] * v2[3] * v3[4] * v4[0] * v5[5]) + (-1 * v0[1] * v1[2] * v2[3] * v3[4] * v4[5] * v5[0]) + (-1 * v0[1] * v1[2] * v2[3] * v3[5] * v4[0] * v5[4]) + (v0[1] * v1[2] * v2[3] * v3[5] * v4[4] * v5[0]) + (v0[1] * v1[2] * v2[4] * v3[0] * v4[3] * v5[5]) + (-1 * v0[1] * v1[2] * v2[4] * v3[0] * v4[5] * v5[3]) + (-1 * v0[1] * v1[2] * v2[4] * v3[3] * v4[0] * v5[5]) + (v0[1] * v1[2] * v2[4] * v3[3] * v4[5] * v5[0]) + (v0[1] * v1[2] * v2[4] * v3[5] * v4[0] * v5[3]) + (-1 * v0[1] * v1[2] * v2[4] * v3[5] * v4[3] * v5[0]) + (-1 * v0[1] * v1[2] * v2[5] * v3[0] * v4[3] * v5[4]) + (v0[1] * v1[2] * v2[5] * v3[0] * v4[4] * v5[3]) + (v0[1] * v1[2] * v2[5] * v3[3] * v4[0] * v5[4]) + (-1 * v0[1] * v1[2] * v2[5] * v3[3] * v4[4] * v5[0]) + (-1 * v0[1] * v1[2] * v2[5] * v3[4] * v4[0] * v5[3]) + (v0[1] * v1[2] * v2[5] * v3[4] * v4[3] * v5[0]) + (-1 * v0[1] * v1[3] * v2[0] * v3[2] * v4[4] * v5[5]) + (v0[1] * v1[3] * v2[0] * v3[2] * v4[5] * v5[4]) + (v0[1] * v1[3] * v2[0] * v3[4] * v4[2] * v5[5]) + (-1 * v0[1] * v1[3] * v2[0] * v3[4] * v4[5] * v5[2]) + (-1 * v0[1] * v1[3] * v2[0] * v3[5] * v4[2] * v5[4]) + (v0[1] * v1[3] * v2[0] * v3[5] * v4[4] * v5[2]) + (v0[1] * v1[3] * v2[2] * v3[0] * v4[4] * v5[5]) + (-1 * v0[1] * v1[3] * v2[2] * v3[0] * v4[5] * v5[4]) + (-1 * v0[1] * v1[3] * v2[2] * v3[4] * v4[0] * v5[5]) + (v0[1] * v1[3] * v2[2] * v3[4] * v4[5] * v5[0]) + (v0[1] * v1[3] * v2[2] * v3[5] * v4[0] * v5[4]) + (-1 * v0[1] * v1[3] * v2[2] * v3[5] * v4[4] * v5[0]) + (-1 * v0[1] * v1[3] * v2[4] * v3[0] * v4[2] * v5[5]) + (v0[1] * v1[3] * v2[4] * v3[0] * v4[5] * v5[2]) + (v0[1] * v1[3] * v2[4] * v3[2] * v4[0] * v5[5]) + (-1 * v0[1] * v1[3] * v2[4] * v3[2] * v4[5] * v5[0]) + (-1 * v0[1] * v1[3] * v2[4] * v3[5] * v4[0] * v5[2]) + (v0[1] * v1[3] * v2[4] * v3[5] * v4[2] * v5[0]) + (v0[1] * v1[3] * v2[5] * v3[0] * v4[2] * v5[4]) + (-1 * v0[1] * v1[3] * v2[5] * v3[0] * v4[4] * v5[2]) + (-1 * v0[1] * v1[3] * v2[5] * v3[2] * v4[0] * v5[4]) + (v0[1] * v1[3] * v2[5] * v3[2] * v4[4] * v5[0]) + (v0[1] * v1[3] * v2[5] * v3[4] * v4[0] * v5[2]) + (-1 * v0[1] * v1[3] * v2[5] * v3[4] * v4[2] * v5[0]) + (v0[1] * v1[4] * v2[0] * v3[2] * v4[3] * v5[5]) + (-1 * v0[1] * v1[4] * v2[0] * v3[2] * v4[5] * v5[3]) + (-1 * v0[1] * v1[4] * v2[0] * v3[3] * v4[2] * v5[5]) + (v0[1] * v1[4] * v2[0] * v3[3] * v4[5] * v5[2]) + (v0[1] * v1[4] * v2[0] * v3[5] * v4[2] * v5[3]) + (-1 * v0[1] * v1[4] * v2[0] * v3[5] * v4[3] * v5[2]) + (-1 * v0[1] * v1[4] * v2[2] * v3[0] * v4[3] * v5[5]) + (v0[1] * v1[4] * v2[2] * v3[0] * v4[5] * v5[3]) + (v0[1] * v1[4] * v2[2] * v3[3] * v4[0] * v5[5]) + (-1 * v0[1] * v1[4] * v2[2] * v3[3] * v4[5] * v5[0]) + (-1 * v0[1] * v1[4] * v2[2] * v3[5] * v4[0] * v5[3]) + (v0[1] * v1[4] * v2[2] * v3[5] * v4[3] * v5[0]) + (v0[1] * v1[4] * v2[3] * v3[0] * v4[2] * v5[5]) + (-1 * v0[1] * v1[4] * v2[3] * v3[0] * v4[5] * v5[2]) + (-1 * v0[1] * v1[4] * v2[3] * v3[2] * v4[0] * v5[5]) + (v0[1] * v1[4] * v2[3] * v3[2] * v4[5] * v5[0]) + (v0[1] * v1[4] * v2[3] * v3[5] * v4[0] * v5[2]) + (-1 * v0[1] * v1[4] * v2[3] * v3[5] * v4[2] * v5[0]) + (-1 * v0[1] * v1[4] * v2[5] * v3[0] * v4[2] * v5[3]) + (v0[1] * v1[4] * v2[5] * v3[0] * v4[3] * v5[2]) + (v0[1] * v1[4] * v2[5] * v3[2] * v4[0] * v5[3]) + (-1 * v0[1] * v1[4] * v2[5] * v3[2] * v4[3] * v5[0]) + (-1 * v0[1] * v1[4] * v2[5] * v3[3] * v4[0] * v5[2]) + (v0[1] * v1[4] * v2[5] * v3[3] * v4[2] * v5[0]) + (-1 * v0[1] * v1[5] * v2[0] * v3[2] * v4[3] * v5[4]) + (v0[1] * v1[5] * v2[0] * v3[2] * v4[4] * v5[3]) + (v0[1] * v1[5] * v2[0] * v3[3] * v4[2] * v5[4]) + (-1 * v0[1] * v1[5] * v2[0] * v3[3] * v4[4] * v5[2]) + (-1 * v0[1] * v1[5] * v2[0] * v3[4] * v4[2] * v5[3]) + (v0[1] * v1[5] * v2[0] * v3[4] * v4[3] * v5[2]) + (v0[1] * v1[5] * v2[2] * v3[0] * v4[3] * v5[4]) + (-1 * v0[1] * v1[5] * v2[2] * v3[0] * v4[4] * v5[3]) + (-1 * v0[1] * v1[5] * v2[2] * v3[3] * v4[0] * v5[4]) + (v0[1] * v1[5] * v2[2] * v3[3] * v4[4] * v5[0]) + (v0[1] * v1[5] * v2[2] * v3[4] * v4[0] * v5[3]) + (-1 * v0[1] * v1[5] * v2[2] * v3[4] * v4[3] * v5[0]) + (-1 * v0[1] * v1[5] * v2[3] * v3[0] * v4[2] * v5[4]) + (v0[1] * v1[5] * v2[3] * v3[0] * v4[4] * v5[2]) + (v0[1] * v1[5] * v2[3] * v3[2] * v4[0] * v5[4]) + (-1 * v0[1] * v1[5] * v2[3] * v3[2] * v4[4] * v5[0]) + (-1 * v0[1] * v1[5] * v2[3] * v3[4] * v4[0] * v5[2]) + (v0[1] * v1[5] * v2[3] * v3[4] * v4[2] * v5[0]) + (v0[1] * v1[5] * v2[4] * v3[0] * v4[2] * v5[3]) + (-1 * v0[1] * v1[5] * v2[4] * v3[0] * v4[3] * v5[2]) + (-1 * v0[1] * v1[5] * v2[4] * v3[2] * v4[0] * v5[3]) + (v0[1] * v1[5] * v2[4] * v3[2] * v4[3] * v5[0]) + (v0[1] * v1[5] * v2[4] * v3[3] * v4[0] * v5[2]) + (-1 * v0[1] * v1[5] * v2[4] * v3[3] * v4[2] * v5[0]) + (v0[2] * v1[0] * v2[1] * v3[3] * v4[4] * v5[5]) + (-1 * v0[2] * v1[0] * v2[1] * v3[3] * v4[5] * v5[4]) + (-1 * v0[2] * v1[0] * v2[1] * v3[4] * v4[3] * v5[5]) + (v0[2] * v1[0] * v2[1] * v3[4] * v4[5] * v5[3]) + (v0[2] * v1[0] * v2[1] * v3[5] * v4[3] * v5[4]) + (-1 * v0[2] * v1[0] * v2[1] * v3[5] * v4[4] * v5[3]) + (-1 * v0[2] * v1[0] * v2[3] * v3[1] * v4[4] * v5[5]) + (v0[2] * v1[0] * v2[3] * v3[1] * v4[5] * v5[4]) + (v0[2] * v1[0] * v2[3] * v3[4] * v4[1] * v5[5]) + (-1 * v0[2] * v1[0] * v2[3] * v3[4] * v4[5] * v5[1]) + (-1 * v0[2] * v1[0] * v2[3] * v3[5] * v4[1] * v5[4]) + (v0[2] * v1[0] * v2[3] * v3[5] * v4[4] * v5[1]) + (v0[2] * v1[0] * v2[4] * v3[1] * v4[3] * v5[5]) + (-1 * v0[2] * v1[0] * v2[4] * v3[1] * v4[5] * v5[3]) + (-1 * v0[2] * v1[0] * v2[4] * v3[3] * v4[1] * v5[5]) + (v0[2] * v1[0] * v2[4] * v3[3] * v4[5] * v5[1]) + (v0[2] * v1[0] * v2[4] * v3[5] * v4[1] * v5[3]) + (-1 * v0[2] * v1[0] * v2[4] * v3[5] * v4[3] * v5[1]) + (-1 * v0[2] * v1[0] * v2[5] * v3[1] * v4[3] * v5[4]) + (v0[2] * v1[0] * v2[5] * v3[1] * v4[4] * v5[3]) + (v0[2] * v1[0] * v2[5] * v3[3] * v4[1] * v5[4]) + (-1 * v0[2] * v1[0] * v2[5] * v3[3] * v4[4] * v5[1]) + (-1 * v0[2] * v1[0] * v2[5] * v3[4] * v4[1] * v5[3]) + (v0[2] * v1[0] * v2[5] * v3[4] * v4[3] * v5[1]) + (-1 * v0[2] * v1[1] * v2[0] * v3[3] * v4[4] * v5[5]) + (v0[2] * v1[1] * v2[0] * v3[3] * v4[5] * v5[4]) + (v0[2] * v1[1] * v2[0] * v3[4] * v4[3] * v5[5]) + (-1 * v0[2] * v1[1] * v2[0] * v3[4] * v4[5] * v5[3]) + (-1 * v0[2] * v1[1] * v2[0] * v3[5] * v4[3] * v5[4]) + (v0[2] * v1[1] * v2[0] * v3[5] * v4[4] * v5[3]) + (v0[2] * v1[1] * v2[3] * v3[0] * v4[4] * v5[5]) + (-1 * v0[2] * v1[1] * v2[3] * v3[0] * v4[5] * v5[4]) + (-1 * v0[2] * v1[1] * v2[3] * v3[4] * v4[0] * v5[5]) + (v0[2] * v1[1] * v2[3] * v3[4] * v4[5] * v5[0]) + (v0[2] * v1[1] * v2[3] * v3[5] * v4[0] * v5[4]) + (-1 * v0[2] * v1[1] * v2[3] * v3[5] * v4[4] * v5[0]) + (-1 * v0[2] * v1[1] * v2[4] * v3[0] * v4[3] * v5[5]) + (v0[2] * v1[1] * v2[4] * v3[0] * v4[5] * v5[3]) + (v0[2] * v1[1] * v2[4] * v3[3] * v4[0] * v5[5]) + (-1 * v0[2] * v1[1] * v2[4] * v3[3] * v4[5] * v5[0]) + (-1 * v0[2] * v1[1] * v2[4] * v3[5] * v4[0] * v5[3]) + (v0[2] * v1[1] * v2[4] * v3[5] * v4[3] * v5[0]) + (v0[2] * v1[1] * v2[5] * v3[0] * v4[3] * v5[4]) + (-1 * v0[2] * v1[1] * v2[5] * v3[0] * v4[4] * v5[3]) + (-1 * v0[2] * v1[1] * v2[5] * v3[3] * v4[0] * v5[4]) + (v0[2] * v1[1] * v2[5] * v3[3] * v4[4] * v5[0]) + (v0[2] * v1[1] * v2[5] * v3[4] * v4[0] * v5[3]) + (-1 * v0[2] * v1[1] * v2[5] * v3[4] * v4[3] * v5[0]) + (v0[2] * v1[3] * v2[0] * v3[1] * v4[4] * v5[5]) + (-1 * v0[2] * v1[3] * v2[0] * v3[1] * v4[5] * v5[4]) + (-1 * v0[2] * v1[3] * v2[0] * v3[4] * v4[1] * v5[5]) + (v0[2] * v1[3] * v2[0] * v3[4] * v4[5] * v5[1]) + (v0[2] * v1[3] * v2[0] * v3[5] * v4[1] * v5[4]) + (-1 * v0[2] * v1[3] * v2[0] * v3[5] * v4[4] * v5[1]) + (-1 * v0[2] * v1[3] * v2[1] * v3[0] * v4[4] * v5[5]) + (v0[2] * v1[3] * v2[1] * v3[0] * v4[5] * v5[4]) + (v0[2] * v1[3] * v2[1] * v3[4] * v4[0] * v5[5]) + (-1 * v0[2] * v1[3] * v2[1] * v3[4] * v4[5] * v5[0]) + (-1 * v0[2] * v1[3] * v2[1] * v3[5] * v4[0] * v5[4]) + (v0[2] * v1[3] * v2[1] * v3[5] * v4[4] * v5[0]) + (v0[2] * v1[3] * v2[4] * v3[0] * v4[1] * v5[5]) + (-1 * v0[2] * v1[3] * v2[4] * v3[0] * v4[5] * v5[1]) + (-1 * v0[2] * v1[3] * v2[4] * v3[1] * v4[0] * v5[5]) + (v0[2] * v1[3] * v2[4] * v3[1] * v4[5] * v5[0]) + (v0[2] * v1[3] * v2[4] * v3[5] * v4[0] * v5[1]) + (-1 * v0[2] * v1[3] * v2[4] * v3[5] * v4[1] * v5[0]) + (-1 * v0[2] * v1[3] * v2[5] * v3[0] * v4[1] * v5[4]) + (v0[2] * v1[3] * v2[5] * v3[0] * v4[4] * v5[1]) + (v0[2] * v1[3] * v2[5] * v3[1] * v4[0] * v5[4]) + (-1 * v0[2] * v1[3] * v2[5] * v3[1] * v4[4] * v5[0]) + (-1 * v0[2] * v1[3] * v2[5] * v3[4] * v4[0] * v5[1]) + (v0[2] * v1[3] * v2[5] * v3[4] * v4[1] * v5[0]) + (-1 * v0[2] * v1[4] * v2[0] * v3[1] * v4[3] * v5[5]) + (v0[2] * v1[4] * v2[0] * v3[1] * v4[5] * v5[3]) + (v0[2] * v1[4] * v2[0] * v3[3] * v4[1] * v5[5]) + (-1 * v0[2] * v1[4] * v2[0] * v3[3] * v4[5] * v5[1]) + (-1 * v0[2] * v1[4] * v2[0] * v3[5] * v4[1] * v5[3]) + (v0[2] * v1[4] * v2[0] * v3[5] * v4[3] * v5[1]) + (v0[2] * v1[4] * v2[1] * v3[0] * v4[3] * v5[5]) + (-1 * v0[2] * v1[4] * v2[1] * v3[0] * v4[5] * v5[3]) + (-1 * v0[2] * v1[4] * v2[1] * v3[3] * v4[0] * v5[5]) + (v0[2] * v1[4] * v2[1] * v3[3] * v4[5] * v5[0]) + (v0[2] * v1[4] * v2[1] * v3[5] * v4[0] * v5[3]) + (-1 * v0[2] * v1[4] * v2[1] * v3[5] * v4[3] * v5[0]) + (-1 * v0[2] * v1[4] * v2[3] * v3[0] * v4[1] * v5[5]) + (v0[2] * v1[4] * v2[3] * v3[0] * v4[5] * v5[1]) + (v0[2] * v1[4] * v2[3] * v3[1] * v4[0] * v5[5]) + (-1 * v0[2] * v1[4] * v2[3] * v3[1] * v4[5] * v5[0]) + (-1 * v0[2] * v1[4] * v2[3] * v3[5] * v4[0] * v5[1]) + (v0[2] * v1[4] * v2[3] * v3[5] * v4[1] * v5[0]) + (v0[2] * v1[4] * v2[5] * v3[0] * v4[1] * v5[3]) + (-1 * v0[2] * v1[4] * v2[5] * v3[0] * v4[3] * v5[1]) + (-1 * v0[2] * v1[4] * v2[5] * v3[1] * v4[0] * v5[3]) + (v0[2] * v1[4] * v2[5] * v3[1] * v4[3] * v5[0]) + (v0[2] * v1[4] * v2[5] * v3[3] * v4[0] * v5[1]) + (-1 * v0[2] * v1[4] * v2[5] * v3[3] * v4[1] * v5[0]) + (v0[2] * v1[5] * v2[0] * v3[1] * v4[3] * v5[4]) + (-1 * v0[2] * v1[5] * v2[0] * v3[1] * v4[4] * v5[3]) + (-1 * v0[2] * v1[5] * v2[0] * v3[3] * v4[1] * v5[4]) + (v0[2] * v1[5] * v2[0] * v3[3] * v4[4] * v5[1]) + (v0[2] * v1[5] * v2[0] * v3[4] * v4[1] * v5[3]) + (-1 * v0[2] * v1[5] * v2[0] * v3[4] * v4[3] * v5[1]) + (-1 * v0[2] * v1[5] * v2[1] * v3[0] * v4[3] * v5[4]) + (v0[2] * v1[5] * v2[1] * v3[0] * v4[4] * v5[3]) + (v0[2] * v1[5] * v2[1] * v3[3] * v4[0] * v5[4]) + (-1 * v0[2] * v1[5] * v2[1] * v3[3] * v4[4] * v5[0]) + (-1 * v0[2] * v1[5] * v2[1] * v3[4] * v4[0] * v5[3]) + (v0[2] * v1[5] * v2[1] * v3[4] * v4[3] * v5[0]) + (v0[2] * v1[5] * v2[3] * v3[0] * v4[1] * v5[4]) + (-1 * v0[2] * v1[5] * v2[3] * v3[0] * v4[4] * v5[1]) + (-1 * v0[2] * v1[5] * v2[3] * v3[1] * v4[0] * v5[4]) + (v0[2] * v1[5] * v2[3] * v3[1] * v4[4] * v5[0]) + (v0[2] * v1[5] * v2[3] * v3[4] * v4[0] * v5[1]) + (-1 * v0[2] * v1[5] * v2[3] * v3[4] * v4[1] * v5[0]) + (-1 * v0[2] * v1[5] * v2[4] * v3[0] * v4[1] * v5[3]) + (v0[2] * v1[5] * v2[4] * v3[0] * v4[3] * v5[1]) + (v0[2] * v1[5] * v2[4] * v3[1] * v4[0] * v5[3]) + (-1 * v0[2] * v1[5] * v2[4] * v3[1] * v4[3] * v5[0]) + (-1 * v0[2] * v1[5] * v2[4] * v3[3] * v4[0] * v5[1]) + (v0[2] * v1[5] * v2[4] * v3[3] * v4[1] * v5[0]) + (-1 * v0[3] * v1[0] * v2[1] * v3[2] * v4[4] * v5[5]) + (v0[3] * v1[0] * v2[1] * v3[2] * v4[5] * v5[4]) + (v0[3] * v1[0] * v2[1] * v3[4] * v4[2] * v5[5]) + (-1 * v0[3] * v1[0] * v2[1] * v3[4] * v4[5] * v5[2]) + (-1 * v0[3] * v1[0] * v2[1] * v3[5] * v4[2] * v5[4]) + (v0[3] * v1[0] * v2[1] * v3[5] * v4[4] * v5[2]) + (v0[3] * v1[0] * v2[2] * v3[1] * v4[4] * v5[5]) + (-1 * v0[3] * v1[0] * v2[2] * v3[1] * v4[5] * v5[4]) + (-1 * v0[3] * v1[0] * v2[2] * v3[4] * v4[1] * v5[5]) + (v0[3] * v1[0] * v2[2] * v3[4] * v4[5] * v5[1]) + (v0[3] * v1[0] * v2[2] * v3[5] * v4[1] * v5[4]) + (-1 * v0[3] * v1[0] * v2[2] * v3[5] * v4[4] * v5[1]) + (-1 * v0[3] * v1[0] * v2[4] * v3[1] * v4[2] * v5[5]) + (v0[3] * v1[0] * v2[4] * v3[1] * v4[5] * v5[2]) + (v0[3] * v1[0] * v2[4] * v3[2] * v4[1] * v5[5]) + (-1 * v0[3] * v1[0] * v2[4] * v3[2] * v4[5] * v5[1]) + (-1 * v0[3] * v1[0] * v2[4] * v3[5] * v4[1] * v5[2]) + (v0[3] * v1[0] * v2[4] * v3[5] * v4[2] * v5[1]) + (v0[3] * v1[0] * v2[5] * v3[1] * v4[2] * v5[4]) + (-1 * v0[3] * v1[0] * v2[5] * v3[1] * v4[4] * v5[2]) + (-1 * v0[3] * v1[0] * v2[5] * v3[2] * v4[1] * v5[4]) + (v0[3] * v1[0] * v2[5] * v3[2] * v4[4] * v5[1]) + (v0[3] * v1[0] * v2[5] * v3[4] * v4[1] * v5[2]) + (-1 * v0[3] * v1[0] * v2[5] * v3[4] * v4[2] * v5[1]) + (v0[3] * v1[1] * v2[0] * v3[2] * v4[4] * v5[5]) + (-1 * v0[3] * v1[1] * v2[0] * v3[2] * v4[5] * v5[4]) + (-1 * v0[3] * v1[1] * v2[0] * v3[4] * v4[2] * v5[5]) + (v0[3] * v1[1] * v2[0] * v3[4] * v4[5] * v5[2]) + (v0[3] * v1[1] * v2[0] * v3[5] * v4[2] * v5[4]) + (-1 * v0[3] * v1[1] * v2[0] * v3[5] * v4[4] * v5[2]) + (-1 * v0[3] * v1[1] * v2[2] * v3[0] * v4[4] * v5[5]) + (v0[3] * v1[1] * v2[2] * v3[0] * v4[5] * v5[4]) + (v0[3] * v1[1] * v2[2] * v3[4] * v4[0] * v5[5]) + (-1 * v0[3] * v1[1] * v2[2] * v3[4] * v4[5] * v5[0]) + (-1 * v0[3] * v1[1] * v2[2] * v3[5] * v4[0] * v5[4]) + (v0[3] * v1[1] * v2[2] * v3[5] * v4[4] * v5[0]) + (v0[3] * v1[1] * v2[4] * v3[0] * v4[2] * v5[5]) + (-1 * v0[3] * v1[1] * v2[4] * v3[0] * v4[5] * v5[2]) + (-1 * v0[3] * v1[1] * v2[4] * v3[2] * v4[0] * v5[5]) + (v0[3] * v1[1] * v2[4] * v3[2] * v4[5] * v5[0]) + (v0[3] * v1[1] * v2[4] * v3[5] * v4[0] * v5[2]) + (-1 * v0[3] * v1[1] * v2[4] * v3[5] * v4[2] * v5[0]) + (-1 * v0[3] * v1[1] * v2[5] * v3[0] * v4[2] * v5[4]) + (v0[3] * v1[1] * v2[5] * v3[0] * v4[4] * v5[2]) + (v0[3] * v1[1] * v2[5] * v3[2] * v4[0] * v5[4]) + (-1 * v0[3] * v1[1] * v2[5] * v3[2] * v4[4] * v5[0]) + (-1 * v0[3] * v1[1] * v2[5] * v3[4] * v4[0] * v5[2]) + (v0[3] * v1[1] * v2[5] * v3[4] * v4[2] * v5[0]) + (-1 * v0[3] * v1[2] * v2[0] * v3[1] * v4[4] * v5[5]) + (v0[3] * v1[2] * v2[0] * v3[1] * v4[5] * v5[4]) + (v0[3] * v1[2] * v2[0] * v3[4] * v4[1] * v5[5]) + (-1 * v0[3] * v1[2] * v2[0] * v3[4] * v4[5] * v5[1]) + (-1 * v0[3] * v1[2] * v2[0] * v3[5] * v4[1] * v5[4]) + (v0[3] * v1[2] * v2[0] * v3[5] * v4[4] * v5[1]) + (v0[3] * v1[2] * v2[1] * v3[0] * v4[4] * v5[5]) + (-1 * v0[3] * v1[2] * v2[1] * v3[0] * v4[5] * v5[4]) + (-1 * v0[3] * v1[2] * v2[1] * v3[4] * v4[0] * v5[5]) + (v0[3] * v1[2] * v2[1] * v3[4] * v4[5] * v5[0]) + (v0[3] * v1[2] * v2[1] * v3[5] * v4[0] * v5[4]) + (-1 * v0[3] * v1[2] * v2[1] * v3[5] * v4[4] * v5[0]) + (-1 * v0[3] * v1[2] * v2[4] * v3[0] * v4[1] * v5[5]) + (v0[3] * v1[2] * v2[4] * v3[0] * v4[5] * v5[1]) + (v0[3] * v1[2] * v2[4] * v3[1] * v4[0] * v5[5]) + (-1 * v0[3] * v1[2] * v2[4] * v3[1] * v4[5] * v5[0]) + (-1 * v0[3] * v1[2] * v2[4] * v3[5] * v4[0] * v5[1]) + (v0[3] * v1[2] * v2[4] * v3[5] * v4[1] * v5[0]) + (v0[3] * v1[2] * v2[5] * v3[0] * v4[1] * v5[4]) + (-1 * v0[3] * v1[2] * v2[5] * v3[0] * v4[4] * v5[1]) + (-1 * v0[3] * v1[2] * v2[5] * v3[1] * v4[0] * v5[4]) + (v0[3] * v1[2] * v2[5] * v3[1] * v4[4] * v5[0]) + (v0[3] * v1[2] * v2[5] * v3[4] * v4[0] * v5[1]) + (-1 * v0[3] * v1[2] * v2[5] * v3[4] * v4[1] * v5[0]) + (v0[3] * v1[4] * v2[0] * v3[1] * v4[2] * v5[5]) + (-1 * v0[3] * v1[4] * v2[0] * v3[1] * v4[5] * v5[2]) + (-1 * v0[3] * v1[4] * v2[0] * v3[2] * v4[1] * v5[5]) + (v0[3] * v1[4] * v2[0] * v3[2] * v4[5] * v5[1]) + (v0[3] * v1[4] * v2[0] * v3[5] * v4[1] * v5[2]) + (-1 * v0[3] * v1[4] * v2[0] * v3[5] * v4[2] * v5[1]) + (-1 * v0[3] * v1[4] * v2[1] * v3[0] * v4[2] * v5[5]) + (v0[3] * v1[4] * v2[1] * v3[0] * v4[5] * v5[2]) + (v0[3] * v1[4] * v2[1] * v3[2] * v4[0] * v5[5]) + (-1 * v0[3] * v1[4] * v2[1] * v3[2] * v4[5] * v5[0]) + (-1 * v0[3] * v1[4] * v2[1] * v3[5] * v4[0] * v5[2]) + (v0[3] * v1[4] * v2[1] * v3[5] * v4[2] * v5[0]) + (v0[3] * v1[4] * v2[2] * v3[0] * v4[1] * v5[5]) + (-1 * v0[3] * v1[4] * v2[2] * v3[0] * v4[5] * v5[1]) + (-1 * v0[3] * v1[4] * v2[2] * v3[1] * v4[0] * v5[5]) + (v0[3] * v1[4] * v2[2] * v3[1] * v4[5] * v5[0]) + (v0[3] * v1[4] * v2[2] * v3[5] * v4[0] * v5[1]) + (-1 * v0[3] * v1[4] * v2[2] * v3[5] * v4[1] * v5[0]) + (-1 * v0[3] * v1[4] * v2[5] * v3[0] * v4[1] * v5[2]) + (v0[3] * v1[4] * v2[5] * v3[0] * v4[2] * v5[1]) + (v0[3] * v1[4] * v2[5] * v3[1] * v4[0] * v5[2]) + (-1 * v0[3] * v1[4] * v2[5] * v3[1] * v4[2] * v5[0]) + (-1 * v0[3] * v1[4] * v2[5] * v3[2] * v4[0] * v5[1]) + (v0[3] * v1[4] * v2[5] * v3[2] * v4[1] * v5[0]) + (-1 * v0[3] * v1[5] * v2[0] * v3[1] * v4[2] * v5[4]) + (v0[3] * v1[5] * v2[0] * v3[1] * v4[4] * v5[2]) + (v0[3] * v1[5] * v2[0] * v3[2] * v4[1] * v5[4]) + (-1 * v0[3] * v1[5] * v2[0] * v3[2] * v4[4] * v5[1]) + (-1 * v0[3] * v1[5] * v2[0] * v3[4] * v4[1] * v5[2]) + (v0[3] * v1[5] * v2[0] * v3[4] * v4[2] * v5[1]) + (v0[3] * v1[5] * v2[1] * v3[0] * v4[2] * v5[4]) + (-1 * v0[3] * v1[5] * v2[1] * v3[0] * v4[4] * v5[2]) + (-1 * v0[3] * v1[5] * v2[1] * v3[2] * v4[0] * v5[4]) + (v0[3] * v1[5] * v2[1] * v3[2] * v4[4] * v5[0]) + (v0[3] * v1[5] * v2[1] * v3[4] * v4[0] * v5[2]) + (-1 * v0[3] * v1[5] * v2[1] * v3[4] * v4[2] * v5[0]) + (-1 * v0[3] * v1[5] * v2[2] * v3[0] * v4[1] * v5[4]) + (v0[3] * v1[5] * v2[2] * v3[0] * v4[4] * v5[1]) + (v0[3] * v1[5] * v2[2] * v3[1] * v4[0] * v5[4]) + (-1 * v0[3] * v1[5] * v2[2] * v3[1] * v4[4] * v5[0]) + (-1 * v0[3] * v1[5] * v2[2] * v3[4] * v4[0] * v5[1]) + (v0[3] * v1[5] * v2[2] * v3[4] * v4[1] * v5[0]) + (v0[3] * v1[5] * v2[4] * v3[0] * v4[1] * v5[2]) + (-1 * v0[3] * v1[5] * v2[4] * v3[0] * v4[2] * v5[1]) + (-1 * v0[3] * v1[5] * v2[4] * v3[1] * v4[0] * v5[2]) + (v0[3] * v1[5] * v2[4] * v3[1] * v4[2] * v5[0]) + (v0[3] * v1[5] * v2[4] * v3[2] * v4[0] * v5[1]) + (-1 * v0[3] * v1[5] * v2[4] * v3[2] * v4[1] * v5[0]) + (v0[4] * v1[0] * v2[1] * v3[2] * v4[3] * v5[5]) + (-1 * v0[4] * v1[0] * v2[1] * v3[2] * v4[5] * v5[3]) + (-1 * v0[4] * v1[0] * v2[1] * v3[3] * v4[2] * v5[5]) + (v0[4] * v1[0] * v2[1] * v3[3] * v4[5] * v5[2]) + (v0[4] * v1[0] * v2[1] * v3[5] * v4[2] * v5[3]) + (-1 * v0[4] * v1[0] * v2[1] * v3[5] * v4[3] * v5[2]) + (-1 * v0[4] * v1[0] * v2[2] * v3[1] * v4[3] * v5[5]) + (v0[4] * v1[0] * v2[2] * v3[1] * v4[5] * v5[3]) + (v0[4] * v1[0] * v2[2] * v3[3] * v4[1] * v5[5]) + (-1 * v0[4] * v1[0] * v2[2] * v3[3] * v4[5] * v5[1]) + (-1 * v0[4] * v1[0] * v2[2] * v3[5] * v4[1] * v5[3]) + (v0[4] * v1[0] * v2[2] * v3[5] * v4[3] * v5[1]) + (v0[4] * v1[0] * v2[3] * v3[1] * v4[2] * v5[5]) + (-1 * v0[4] * v1[0] * v2[3] * v3[1] * v4[5] * v5[2]) + (-1 * v0[4] * v1[0] * v2[3] * v3[2] * v4[1] * v5[5]) + (v0[4] * v1[0] * v2[3] * v3[2] * v4[5] * v5[1]) + (v0[4] * v1[0] * v2[3] * v3[5] * v4[1] * v5[2]) + (-1 * v0[4] * v1[0] * v2[3] * v3[5] * v4[2] * v5[1]) + (-1 * v0[4] * v1[0] * v2[5] * v3[1] * v4[2] * v5[3]) + (v0[4] * v1[0] * v2[5] * v3[1] * v4[3] * v5[2]) + (v0[4] * v1[0] * v2[5] * v3[2] * v4[1] * v5[3]) + (-1 * v0[4] * v1[0] * v2[5] * v3[2] * v4[3] * v5[1]) + (-1 * v0[4] * v1[0] * v2[5] * v3[3] * v4[1] * v5[2]) + (v0[4] * v1[0] * v2[5] * v3[3] * v4[2] * v5[1]) + (-1 * v0[4] * v1[1] * v2[0] * v3[2] * v4[3] * v5[5]) + (v0[4] * v1[1] * v2[0] * v3[2] * v4[5] * v5[3]) + (v0[4] * v1[1] * v2[0] * v3[3] * v4[2] * v5[5]) + (-1 * v0[4] * v1[1] * v2[0] * v3[3] * v4[5] * v5[2]) + (-1 * v0[4] * v1[1] * v2[0] * v3[5] * v4[2] * v5[3]) + (v0[4] * v1[1] * v2[0] * v3[5] * v4[3] * v5[2]) + (v0[4] * v1[1] * v2[2] * v3[0] * v4[3] * v5[5]) + (-1 * v0[4] * v1[1] * v2[2] * v3[0] * v4[5] * v5[3]) + (-1 * v0[4] * v1[1] * v2[2] * v3[3] * v4[0] * v5[5]) + (v0[4] * v1[1] * v2[2] * v3[3] * v4[5] * v5[0]) + (v0[4] * v1[1] * v2[2] * v3[5] * v4[0] * v5[3]) + (-1 * v0[4] * v1[1] * v2[2] * v3[5] * v4[3] * v5[0]) + (-1 * v0[4] * v1[1] * v2[3] * v3[0] * v4[2] * v5[5]) + (v0[4] * v1[1] * v2[3] * v3[0] * v4[5] * v5[2]) + (v0[4] * v1[1] * v2[3] * v3[2] * v4[0] * v5[5]) + (-1 * v0[4] * v1[1] * v2[3] * v3[2] * v4[5] * v5[0]) + (-1 * v0[4] * v1[1] * v2[3] * v3[5] * v4[0] * v5[2]) + (v0[4] * v1[1] * v2[3] * v3[5] * v4[2] * v5[0]) + (v0[4] * v1[1] * v2[5] * v3[0] * v4[2] * v5[3]) + (-1 * v0[4] * v1[1] * v2[5] * v3[0] * v4[3] * v5[2]) + (-1 * v0[4] * v1[1] * v2[5] * v3[2] * v4[0] * v5[3]) + (v0[4] * v1[1] * v2[5] * v3[2] * v4[3] * v5[0]) + (v0[4] * v1[1] * v2[5] * v3[3] * v4[0] * v5[2]) + (-1 * v0[4] * v1[1] * v2[5] * v3[3] * v4[2] * v5[0]) + (v0[4] * v1[2] * v2[0] * v3[1] * v4[3] * v5[5]) + (-1 * v0[4] * v1[2] * v2[0] * v3[1] * v4[5] * v5[3]) + (-1 * v0[4] * v1[2] * v2[0] * v3[3] * v4[1] * v5[5]) + (v0[4] * v1[2] * v2[0] * v3[3] * v4[5] * v5[1]) + (v0[4] * v1[2] * v2[0] * v3[5] * v4[1] * v5[3]) + (-1 * v0[4] * v1[2] * v2[0] * v3[5] * v4[3] * v5[1]) + (-1 * v0[4] * v1[2] * v2[1] * v3[0] * v4[3] * v5[5]) + (v0[4] * v1[2] * v2[1] * v3[0] * v4[5] * v5[3]) + (v0[4] * v1[2] * v2[1] * v3[3] * v4[0] * v5[5]) + (-1 * v0[4] * v1[2] * v2[1] * v3[3] * v4[5] * v5[0]) + (-1 * v0[4] * v1[2] * v2[1] * v3[5] * v4[0] * v5[3]) + (v0[4] * v1[2] * v2[1] * v3[5] * v4[3] * v5[0]) + (v0[4] * v1[2] * v2[3] * v3[0] * v4[1] * v5[5]) + (-1 * v0[4] * v1[2] * v2[3] * v3[0] * v4[5] * v5[1]) + (-1 * v0[4] * v1[2] * v2[3] * v3[1] * v4[0] * v5[5]) + (v0[4] * v1[2] * v2[3] * v3[1] * v4[5] * v5[0]) + (v0[4] * v1[2] * v2[3] * v3[5] * v4[0] * v5[1]) + (-1 * v0[4] * v1[2] * v2[3] * v3[5] * v4[1] * v5[0]) + (-1 * v0[4] * v1[2] * v2[5] * v3[0] * v4[1] * v5[3]) + (v0[4] * v1[2] * v2[5] * v3[0] * v4[3] * v5[1]) + (v0[4] * v1[2] * v2[5] * v3[1] * v4[0] * v5[3]) + (-1 * v0[4] * v1[2] * v2[5] * v3[1] * v4[3] * v5[0]) + (-1 * v0[4] * v1[2] * v2[5] * v3[3] * v4[0] * v5[1]) + (v0[4] * v1[2] * v2[5] * v3[3] * v4[1] * v5[0]) + (-1 * v0[4] * v1[3] * v2[0] * v3[1] * v4[2] * v5[5]) + (v0[4] * v1[3] * v2[0] * v3[1] * v4[5] * v5[2]) + (v0[4] * v1[3] * v2[0] * v3[2] * v4[1] * v5[5]) + (-1 * v0[4] * v1[3] * v2[0] * v3[2] * v4[5] * v5[1]) + (-1 * v0[4] * v1[3] * v2[0] * v3[5] * v4[1] * v5[2]) + (v0[4] * v1[3] * v2[0] * v3[5] * v4[2] * v5[1]) + (v0[4] * v1[3] * v2[1] * v3[0] * v4[2] * v5[5]) + (-1 * v0[4] * v1[3] * v2[1] * v3[0] * v4[5] * v5[2]) + (-1 * v0[4] * v1[3] * v2[1] * v3[2] * v4[0] * v5[5]) + (v0[4] * v1[3] * v2[1] * v3[2] * v4[5] * v5[0]) + (v0[4] * v1[3] * v2[1] * v3[5] * v4[0] * v5[2]) + (-1 * v0[4] * v1[3] * v2[1] * v3[5] * v4[2] * v5[0]) + (-1 * v0[4] * v1[3] * v2[2] * v3[0] * v4[1] * v5[5]) + (v0[4] * v1[3] * v2[2] * v3[0] * v4[5] * v5[1]) + (v0[4] * v1[3] * v2[2] * v3[1] * v4[0] * v5[5]) + (-1 * v0[4] * v1[3] * v2[2] * v3[1] * v4[5] * v5[0]) + (-1 * v0[4] * v1[3] * v2[2] * v3[5] * v4[0] * v5[1]) + (v0[4] * v1[3] * v2[2] * v3[5] * v4[1] * v5[0]) + (v0[4] * v1[3] * v2[5] * v3[0] * v4[1] * v5[2]) + (-1 * v0[4] * v1[3] * v2[5] * v3[0] * v4[2] * v5[1]) + (-1 * v0[4] * v1[3] * v2[5] * v3[1] * v4[0] * v5[2]) + (v0[4] * v1[3] * v2[5] * v3[1] * v4[2] * v5[0]) + (v0[4] * v1[3] * v2[5] * v3[2] * v4[0] * v5[1]) + (-1 * v0[4] * v1[3] * v2[5] * v3[2] * v4[1] * v5[0]) + (v0[4] * v1[5] * v2[0] * v3[1] * v4[2] * v5[3]) + (-1 * v0[4] * v1[5] * v2[0] * v3[1] * v4[3] * v5[2]) + (-1 * v0[4] * v1[5] * v2[0] * v3[2] * v4[1] * v5[3]) + (v0[4] * v1[5] * v2[0] * v3[2] * v4[3] * v5[1]) + (v0[4] * v1[5] * v2[0] * v3[3] * v4[1] * v5[2]) + (-1 * v0[4] * v1[5] * v2[0] * v3[3] * v4[2] * v5[1]) + (-1 * v0[4] * v1[5] * v2[1] * v3[0] * v4[2] * v5[3]) + (v0[4] * v1[5] * v2[1] * v3[0] * v4[3] * v5[2]) + (v0[4] * v1[5] * v2[1] * v3[2] * v4[0] * v5[3]) + (-1 * v0[4] * v1[5] * v2[1] * v3[2] * v4[3] * v5[0]) + (-1 * v0[4] * v1[5] * v2[1] * v3[3] * v4[0] * v5[2]) + (v0[4] * v1[5] * v2[1] * v3[3] * v4[2] * v5[0]) + (v0[4] * v1[5] * v2[2] * v3[0] * v4[1] * v5[3]) + (-1 * v0[4] * v1[5] * v2[2] * v3[0] * v4[3] * v5[1]) + (-1 * v0[4] * v1[5] * v2[2] * v3[1] * v4[0] * v5[3]) + (v0[4] * v1[5] * v2[2] * v3[1] * v4[3] * v5[0]) + (v0[4] * v1[5] * v2[2] * v3[3] * v4[0] * v5[1]) + (-1 * v0[4] * v1[5] * v2[2] * v3[3] * v4[1] * v5[0]) + (-1 * v0[4] * v1[5] * v2[3] * v3[0] * v4[1] * v5[2]) + (v0[4] * v1[5] * v2[3] * v3[0] * v4[2] * v5[1]) + (v0[4] * v1[5] * v2[3] * v3[1] * v4[0] * v5[2]) + (-1 * v0[4] * v1[5] * v2[3] * v3[1] * v4[2] * v5[0]) + (-1 * v0[4] * v1[5] * v2[3] * v3[2] * v4[0] * v5[1]) + (v0[4] * v1[5] * v2[3] * v3[2] * v4[1] * v5[0]) + (-1 * v0[5] * v1[0] * v2[1] * v3[2] * v4[3] * v5[4]) + (v0[5] * v1[0] * v2[1] * v3[2] * v4[4] * v5[3]) + (v0[5] * v1[0] * v2[1] * v3[3] * v4[2] * v5[4]) + (-1 * v0[5] * v1[0] * v2[1] * v3[3] * v4[4] * v5[2]) + (-1 * v0[5] * v1[0] * v2[1] * v3[4] * v4[2] * v5[3]) + (v0[5] * v1[0] * v2[1] * v3[4] * v4[3] * v5[2]) + (v0[5] * v1[0] * v2[2] * v3[1] * v4[3] * v5[4]) + (-1 * v0[5] * v1[0] * v2[2] * v3[1] * v4[4] * v5[3]) + (-1 * v0[5] * v1[0] * v2[2] * v3[3] * v4[1] * v5[4]) + (v0[5] * v1[0] * v2[2] * v3[3] * v4[4] * v5[1]) + (v0[5] * v1[0] * v2[2] * v3[4] * v4[1] * v5[3]) + (-1 * v0[5] * v1[0] * v2[2] * v3[4] * v4[3] * v5[1]) + (-1 * v0[5] * v1[0] * v2[3] * v3[1] * v4[2] * v5[4]) + (v0[5] * v1[0] * v2[3] * v3[1] * v4[4] * v5[2]) + (v0[5] * v1[0] * v2[3] * v3[2] * v4[1] * v5[4]) + (-1 * v0[5] * v1[0] * v2[3] * v3[2] * v4[4] * v5[1]) + (-1 * v0[5] * v1[0] * v2[3] * v3[4] * v4[1] * v5[2]) + (v0[5] * v1[0] * v2[3] * v3[4] * v4[2] * v5[1]) + (v0[5] * v1[0] * v2[4] * v3[1] * v4[2] * v5[3]) + (-1 * v0[5] * v1[0] * v2[4] * v3[1] * v4[3] * v5[2]) + (-1 * v0[5] * v1[0] * v2[4] * v3[2] * v4[1] * v5[3]) + (v0[5] * v1[0] * v2[4] * v3[2] * v4[3] * v5[1]) + (v0[5] * v1[0] * v2[4] * v3[3] * v4[1] * v5[2]) + (-1 * v0[5] * v1[0] * v2[4] * v3[3] * v4[2] * v5[1]) + (v0[5] * v1[1] * v2[0] * v3[2] * v4[3] * v5[4]) + (-1 * v0[5] * v1[1] * v2[0] * v3[2] * v4[4] * v5[3]) + (-1 * v0[5] * v1[1] * v2[0] * v3[3] * v4[2] * v5[4]) + (v0[5] * v1[1] * v2[0] * v3[3] * v4[4] * v5[2]) + (v0[5] * v1[1] * v2[0] * v3[4] * v4[2] * v5[3]) + (-1 * v0[5] * v1[1] * v2[0] * v3[4] * v4[3] * v5[2]) + (-1 * v0[5] * v1[1] * v2[2] * v3[0] * v4[3] * v5[4]) + (v0[5] * v1[1] * v2[2] * v3[0] * v4[4] * v5[3]) + (v0[5] * v1[1] * v2[2] * v3[3] * v4[0] * v5[4]) + (-1 * v0[5] * v1[1] * v2[2] * v3[3] * v4[4] * v5[0]) + (-1 * v0[5] * v1[1] * v2[2] * v3[4] * v4[0] * v5[3]) + (v0[5] * v1[1] * v2[2] * v3[4] * v4[3] * v5[0]) + (v0[5] * v1[1] * v2[3] * v3[0] * v4[2] * v5[4]) + (-1 * v0[5] * v1[1] * v2[3] * v3[0] * v4[4] * v5[2]) + (-1 * v0[5] * v1[1] * v2[3] * v3[2] * v4[0] * v5[4]) + (v0[5] * v1[1] * v2[3] * v3[2] * v4[4] * v5[0]) + (v0[5] * v1[1] * v2[3] * v3[4] * v4[0] * v5[2]) + (-1 * v0[5] * v1[1] * v2[3] * v3[4] * v4[2] * v5[0]) + (-1 * v0[5] * v1[1] * v2[4] * v3[0] * v4[2] * v5[3]) + (v0[5] * v1[1] * v2[4] * v3[0] * v4[3] * v5[2]) + (v0[5] * v1[1] * v2[4] * v3[2] * v4[0] * v5[3]) + (-1 * v0[5] * v1[1] * v2[4] * v3[2] * v4[3] * v5[0]) + (-1 * v0[5] * v1[1] * v2[4] * v3[3] * v4[0] * v5[2]) + (v0[5] * v1[1] * v2[4] * v3[3] * v4[2] * v5[0]) + (-1 * v0[5] * v1[2] * v2[0] * v3[1] * v4[3] * v5[4]) + (v0[5] * v1[2] * v2[0] * v3[1] * v4[4] * v5[3]) + (v0[5] * v1[2] * v2[0] * v3[3] * v4[1] * v5[4]) + (-1 * v0[5] * v1[2] * v2[0] * v3[3] * v4[4] * v5[1]) + (-1 * v0[5] * v1[2] * v2[0] * v3[4] * v4[1] * v5[3]) + (v0[5] * v1[2] * v2[0] * v3[4] * v4[3] * v5[1]) + (v0[5] * v1[2] * v2[1] * v3[0] * v4[3] * v5[4]) + (-1 * v0[5] * v1[2] * v2[1] * v3[0] * v4[4] * v5[3]) + (-1 * v0[5] * v1[2] * v2[1] * v3[3] * v4[0] * v5[4]) + (v0[5] * v1[2] * v2[1] * v3[3] * v4[4] * v5[0]) + (v0[5] * v1[2] * v2[1] * v3[4] * v4[0] * v5[3]) + (-1 * v0[5] * v1[2] * v2[1] * v3[4] * v4[3] * v5[0]) + (-1 * v0[5] * v1[2] * v2[3] * v3[0] * v4[1] * v5[4]) + (v0[5] * v1[2] * v2[3] * v3[0] * v4[4] * v5[1]) + (v0[5] * v1[2] * v2[3] * v3[1] * v4[0] * v5[4]) + (-1 * v0[5] * v1[2] * v2[3] * v3[1] * v4[4] * v5[0]) + (-1 * v0[5] * v1[2] * v2[3] * v3[4] * v4[0] * v5[1]) + (v0[5] * v1[2] * v2[3] * v3[4] * v4[1] * v5[0]) + (v0[5] * v1[2] * v2[4] * v3[0] * v4[1] * v5[3]) + (-1 * v0[5] * v1[2] * v2[4] * v3[0] * v4[3] * v5[1]) + (-1 * v0[5] * v1[2] * v2[4] * v3[1] * v4[0] * v5[3]) + (v0[5] * v1[2] * v2[4] * v3[1] * v4[3] * v5[0]) + (v0[5] * v1[2] * v2[4] * v3[3] * v4[0] * v5[1]) + (-1 * v0[5] * v1[2] * v2[4] * v3[3] * v4[1] * v5[0]) + (v0[5] * v1[3] * v2[0] * v3[1] * v4[2] * v5[4]) + (-1 * v0[5] * v1[3] * v2[0] * v3[1] * v4[4] * v5[2]) + (-1 * v0[5] * v1[3] * v2[0] * v3[2] * v4[1] * v5[4]) + (v0[5] * v1[3] * v2[0] * v3[2] * v4[4] * v5[1]) + (v0[5] * v1[3] * v2[0] * v3[4] * v4[1] * v5[2]) + (-1 * v0[5] * v1[3] * v2[0] * v3[4] * v4[2] * v5[1]) + (-1 * v0[5] * v1[3] * v2[1] * v3[0] * v4[2] * v5[4]) + (v0[5] * v1[3] * v2[1] * v3[0] * v4[4] * v5[2]) + (v0[5] * v1[3] * v2[1] * v3[2] * v4[0] * v5[4]) + (-1 * v0[5] * v1[3] * v2[1] * v3[2] * v4[4] * v5[0]) + (-1 * v0[5] * v1[3] * v2[1] * v3[4] * v4[0] * v5[2]) + (v0[5] * v1[3] * v2[1] * v3[4] * v4[2] * v5[0]) + (v0[5] * v1[3] * v2[2] * v3[0] * v4[1] * v5[4]) + (-1 * v0[5] * v1[3] * v2[2] * v3[0] * v4[4] * v5[1]) + (-1 * v0[5] * v1[3] * v2[2] * v3[1] * v4[0] * v5[4]) + (v0[5] * v1[3] * v2[2] * v3[1] * v4[4] * v5[0]) + (v0[5] * v1[3] * v2[2] * v3[4] * v4[0] * v5[1]) + (-1 * v0[5] * v1[3] * v2[2] * v3[4] * v4[1] * v5[0]) + (-1 * v0[5] * v1[3] * v2[4] * v3[0] * v4[1] * v5[2]) + (v0[5] * v1[3] * v2[4] * v3[0] * v4[2] * v5[1]) + (v0[5] * v1[3] * v2[4] * v3[1] * v4[0] * v5[2]) + (-1 * v0[5] * v1[3] * v2[4] * v3[1] * v4[2] * v5[0]) + (-1 * v0[5] * v1[3] * v2[4] * v3[2] * v4[0] * v5[1]) + (v0[5] * v1[3] * v2[4] * v3[2] * v4[1] * v5[0]) + (-1 * v0[5] * v1[4] * v2[0] * v3[1] * v4[2] * v5[3]) + (v0[5] * v1[4] * v2[0] * v3[1] * v4[3] * v5[2]) + (v0[5] * v1[4] * v2[0] * v3[2] * v4[1] * v5[3]) + (-1 * v0[5] * v1[4] * v2[0] * v3[2] * v4[3] * v5[1]) + (-1 * v0[5] * v1[4] * v2[0] * v3[3] * v4[1] * v5[2]) + (v0[5] * v1[4] * v2[0] * v3[3] * v4[2] * v5[1]) + (v0[5] * v1[4] * v2[1] * v3[0] * v4[2] * v5[3]) + (-1 * v0[5] * v1[4] * v2[1] * v3[0] * v4[3] * v5[2]) + (-1 * v0[5] * v1[4] * v2[1] * v3[2] * v4[0] * v5[3]) + (v0[5] * v1[4] * v2[1] * v3[2] * v4[3] * v5[0]) + (v0[5] * v1[4] * v2[1] * v3[3] * v4[0] * v5[2]) + (-1 * v0[5] * v1[4] * v2[1] * v3[3] * v4[2] * v5[0]) + (-1 * v0[5] * v1[4] * v2[2] * v3[0] * v4[1] * v5[3]) + (v0[5] * v1[4] * v2[2] * v3[0] * v4[3] * v5[1]) + (v0[5] * v1[4] * v2[2] * v3[1] * v4[0] * v5[3]) + (-1 * v0[5] * v1[4] * v2[2] * v3[1] * v4[3] * v5[0]) + (-1 * v0[5] * v1[4] * v2[2] * v3[3] * v4[0] * v5[1]) + (v0[5] * v1[4] * v2[2] * v3[3] * v4[1] * v5[0]) + (v0[5] * v1[4] * v2[3] * v3[0] * v4[1] * v5[2]) + (-1 * v0[5] * v1[4] * v2[3] * v3[0] * v4[2] * v5[1]) + (-1 * v0[5] * v1[4] * v2[3] * v3[1] * v4[0] * v5[2]) + (v0[5] * v1[4] * v2[3] * v3[1] * v4[2] * v5[0]) + (v0[5] * v1[4] * v2[3] * v3[2] * v4[0] * v5[1]) + (-1 * v0[5] * v1[4] * v2[3] * v3[2] * v4[1] * v5[0]);
}
|
the_stack_data/200144430.c | // RUN: %clang_cc1 %s -emit-llvm -o -
struct Y {};
struct XXX {
struct Y F;
};
void test1() {
(int)&((struct XXX*)(((void *)0)))->F;
}
void test2() {
&((struct XXX*)(((void *)0)))->F;
}
|
the_stack_data/114029.c | #include <stdio.h>
#include <stdlib.h>
void pausar() {
printf("\n Pressione alguma tecla para continuar...");
getch();
}
struct numCMP1{
float numEn1[5];
};
struct numCMP1 numCMP1User1;
struct numCMP2{
float numEn2[5];
};
struct numCMP2 numCMP2User2;
int main(){
int cont, cont1; cont=1; cont1=1;
while(cont<=5) {
printf("\n Insira numero[%d] para vetor [1]: ", cont);
scanf("%f", &numCMP1User1.numEn1[cont]);
printf("\n Insira numero[%d] para vetor [2]: ", cont);
scanf("%f", &numCMP2User2.numEn2[cont]);
for(cont1=1; cont1<=5; cont1++) {
if(
(numCMP1User1.numEn1[cont] == numCMP2User2.numEn2[cont1]) &&
(numCMP2User2.numEn2[cont] == numCMP1User1.numEn1[cont1])
) {
printf("\n [%d] Valor na posicao do vetor eh iqual a de outro vetor. \n", cont1);
}
}
cont++;
}
pausar();
return(0);
}
|
the_stack_data/87637533.c | /* ------------------------------------------
* Copyright (c) 2018, Synopsys, Inc. All rights reserved.
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1) Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2) Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
* 3) Neither the name of the Synopsys, Inc., nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
--------------------------------------------- */
#pragma Code ("modify_seg")
void modify(int list[], int size)
{
int out, in, temp;
for(out=0; out<size; out++)
for(in=out+1; in<size; in++)
if(list[out] > list[in]) {
temp = list[in];
list[in] = list[out];
list[out] = temp;
}
}
#pragma Code ()
int data[] = {4, 8, 2, 6, 7, 8, 10, 5};
void main (void) {
int nItems = sizeof(data) / sizeof(int);
modify(data, nItems);
}
|
the_stack_data/6388743.c | #include <stdio.h>
int main()
{
int arr[16];
int i, j, k, l;
// for(i=0; i<16; i++)arr[i]=i&7;
for(i=0; i<16; i++)arr[i]=i;
for(i=0; i<256; i++)
{
j=rand()&15;
k=rand()&15;
l=arr[j]; arr[j]=arr[k]; arr[k]=l;
}
for(i=0; i<16; i++)printf("%d ", arr[i]);
printf("\n");
}
|
the_stack_data/150143864.c | #include <stdio.h>
int a[11];
int x,y;
int main(){
while(scanf("%d",&a[1]) != EOF){
for(int i=2;i<=10;i++){
scanf("%d",&a[i]);
}
scanf("%d",&y);
y+=30;
int k=0;
for(int i=1;i<=10;i++){
if(a[i]<=y){
k++;
}
}
printf("%d\n",k);
}
return 0;
}
|
the_stack_data/154827316.c | #include <stdio.h>
#include <stdlib.h>
main()
{
int c, n;
n = 0;
while((c = getchar()) != EOF)
if(c == '\n' || c == '\t' || c == ' ')
++n;
printf("%d\n", n);
}
|
the_stack_data/212643863.c | #include <stdio.h>
#include <string.h>
#include <math.h>
#include <openssl/aes.h>
int main()
{
char req_num[12];
unsigned long long longInt; // 190550043697
unsigned char final_key[12];
unsigned char aes_user_key [16];
unsigned char aes_iv [16];
unsigned long long req_num_encrypted;
unsigned char formatted_req_num_encrypted [12];
int operation_amount = 0;
AES_KEY aes_key;
void LongToByteArray(unsigned char byteArray[8], unsigned long longInt) {
int i;
for (i=0; i < 8; i++) {
byteArray[i] = (char)(longInt >> (i*8) & 0xFF);
}
}
unsigned long StrToULong(char str[12]) {
int len = 12;
int i;
unsigned long longInt;
for (i=0; i<len; i++) {
longInt += (str[len - i - 1] - 0x30) * pow(10, i);
}
return longInt;
}
while (strlen(req_num) != 12) {
printf("Request number (12 characters, no spaces): ");
scanf("%12s", req_num);
}
while (operation_amount != 5000 && operation_amount != 2000) {
printf("Number of points (5000 or 2000): ");
scanf("%d", &operation_amount);
}
longInt = StrToULong(req_num);
unsigned char byteArray[8];
memset(byteArray, 0, 8);
LongToByteArray(byteArray, longInt);
memset(aes_user_key,0,0x10);
memset(aes_iv,0,0x10);
strcpy((char *)aes_user_key,"cityManageoffer");
sprintf((char *)aes_iv,"initvector_%d",operation_amount);
AES_set_encrypt_key(aes_user_key,0x80,&aes_key);
memset(&req_num_encrypted,0,0x10);
AES_cbc_encrypt(byteArray,(unsigned char *)&req_num_encrypted,8,&aes_key,aes_iv,1);
sprintf((char *)&formatted_req_num_encrypted,"%llu",req_num_encrypted);
memset(&final_key,0,0xd);
strncpy(final_key, formatted_req_num_encrypted, 12);
printf("%s\n", final_key);
return 0;
}
|
the_stack_data/167331793.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fmessina <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/06 05:48:31 by fmessina #+# #+# */
/* Updated: 2016/11/06 20:24:56 by fmessina ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isalnum(int c)
{
if ((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122))
return (1);
return (0);
}
|
the_stack_data/62637077.c | #include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#endif
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/df(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimagf(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static integer c__6 = 6;
static integer c_n1 = -1;
static integer c__0 = 0;
static doublereal c_b46 = 0.;
static integer c__1 = 1;
static doublereal c_b79 = 1.;
/* > \brief <b> DGELSS solves overdetermined or underdetermined systems for GE matrices</b> */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download DGELSS + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dgelss.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dgelss.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dgelss.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE DGELSS( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, */
/* WORK, LWORK, INFO ) */
/* INTEGER INFO, LDA, LDB, LWORK, M, N, NRHS, RANK */
/* DOUBLE PRECISION RCOND */
/* DOUBLE PRECISION A( LDA, * ), B( LDB, * ), S( * ), WORK( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > DGELSS computes the minimum norm solution to a real linear least */
/* > squares problem: */
/* > */
/* > Minimize 2-norm(| b - A*x |). */
/* > */
/* > using the singular value decomposition (SVD) of A. A is an M-by-N */
/* > matrix which may be rank-deficient. */
/* > */
/* > Several right hand side vectors b and solution vectors x can be */
/* > handled in a single call; they are stored as the columns of the */
/* > M-by-NRHS right hand side matrix B and the N-by-NRHS solution matrix */
/* > X. */
/* > */
/* > The effective rank of A is determined by treating as zero those */
/* > singular values which are less than RCOND times the largest singular */
/* > value. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] M */
/* > \verbatim */
/* > M is INTEGER */
/* > The number of rows of the matrix A. M >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The number of columns of the matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] NRHS */
/* > \verbatim */
/* > NRHS is INTEGER */
/* > The number of right hand sides, i.e., the number of columns */
/* > of the matrices B and X. NRHS >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] A */
/* > \verbatim */
/* > A is DOUBLE PRECISION array, dimension (LDA,N) */
/* > On entry, the M-by-N matrix A. */
/* > On exit, the first f2cmin(m,n) rows of A are overwritten with */
/* > its right singular vectors, stored rowwise. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,M). */
/* > \endverbatim */
/* > */
/* > \param[in,out] B */
/* > \verbatim */
/* > B is DOUBLE PRECISION array, dimension (LDB,NRHS) */
/* > On entry, the M-by-NRHS right hand side matrix B. */
/* > On exit, B is overwritten by the N-by-NRHS solution */
/* > matrix X. If m >= n and RANK = n, the residual */
/* > sum-of-squares for the solution in the i-th column is given */
/* > by the sum of squares of elements n+1:m in that column. */
/* > \endverbatim */
/* > */
/* > \param[in] LDB */
/* > \verbatim */
/* > LDB is INTEGER */
/* > The leading dimension of the array B. LDB >= f2cmax(1,f2cmax(M,N)). */
/* > \endverbatim */
/* > */
/* > \param[out] S */
/* > \verbatim */
/* > S is DOUBLE PRECISION array, dimension (f2cmin(M,N)) */
/* > The singular values of A in decreasing order. */
/* > The condition number of A in the 2-norm = S(1)/S(f2cmin(m,n)). */
/* > \endverbatim */
/* > */
/* > \param[in] RCOND */
/* > \verbatim */
/* > RCOND is DOUBLE PRECISION */
/* > RCOND is used to determine the effective rank of A. */
/* > Singular values S(i) <= RCOND*S(1) are treated as zero. */
/* > If RCOND < 0, machine precision is used instead. */
/* > \endverbatim */
/* > */
/* > \param[out] RANK */
/* > \verbatim */
/* > RANK is INTEGER */
/* > The effective rank of A, i.e., the number of singular values */
/* > which are greater than RCOND*S(1). */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)) */
/* > On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* > \endverbatim */
/* > */
/* > \param[in] LWORK */
/* > \verbatim */
/* > LWORK is INTEGER */
/* > The dimension of the array WORK. LWORK >= 1, and also: */
/* > LWORK >= 3*f2cmin(M,N) + f2cmax( 2*f2cmin(M,N), f2cmax(M,N), NRHS ) */
/* > For good performance, LWORK should generally be larger. */
/* > */
/* > If LWORK = -1, then a workspace query is assumed; the routine */
/* > only calculates the optimal size of the WORK array, returns */
/* > this value as the first entry of the WORK array, and no error */
/* > message related to LWORK is issued by XERBLA. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > > 0: the algorithm for computing the SVD failed to converge; */
/* > if INFO = i, i off-diagonal elements of an intermediate */
/* > bidiagonal form did not converge to zero. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup doubleGEsolve */
/* ===================================================================== */
/* Subroutine */ int dgelss_(integer *m, integer *n, integer *nrhs,
doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork,
integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3, i__4;
doublereal d__1;
/* Local variables */
doublereal anrm, bnrm;
integer itau, lwork_dgebrd__, lwork_dgelqf__, lwork_dgeqrf__,
lwork_dorgbr__, lwork_dormbr__, i__, lwork_dormlq__,
lwork_dormqr__;
extern /* Subroutine */ int dgemm_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *);
integer iascl, ibscl;
extern /* Subroutine */ int dgemv_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *), drscl_(integer *,
doublereal *, doublereal *, integer *);
integer chunk;
doublereal sfmin;
integer minmn;
extern /* Subroutine */ int dcopy_(integer *, doublereal *, integer *,
doublereal *, integer *);
integer maxmn, itaup, itauq, mnthr, iwork;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
integer bl, ie, il;
extern /* Subroutine */ int dgebrd_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
doublereal *, integer *, integer *);
extern doublereal dlamch_(char *);
integer mm;
extern doublereal dlange_(char *, integer *, integer *, doublereal *,
integer *, doublereal *);
integer bdspac;
extern /* Subroutine */ int dgelqf_(integer *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *, integer *),
dlascl_(char *, integer *, integer *, doublereal *, doublereal *,
integer *, integer *, doublereal *, integer *, integer *),
dgeqrf_(integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *, integer *), dlacpy_(char *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *), dlaset_(char *, integer *, integer *,
doublereal *, doublereal *, doublereal *, integer *),
xerbla_(char *, integer *, ftnlen), dbdsqr_(char *, integer *,
integer *, integer *, integer *, doublereal *, doublereal *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
integer *, doublereal *, integer *), dorgbr_(char *,
integer *, integer *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *, integer *);
doublereal bignum;
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern /* Subroutine */ int dormbr_(char *, char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, integer *), dormlq_(char *, char *, integer *,
integer *, integer *, doublereal *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, integer *);
integer ldwork;
extern /* Subroutine */ int dormqr_(char *, char *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *);
integer minwrk, maxwrk;
doublereal smlnum;
logical lquery;
doublereal dum[1], eps, thr;
/* -- LAPACK driver routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Test the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
--s;
--work;
/* Function Body */
*info = 0;
minmn = f2cmin(*m,*n);
maxmn = f2cmax(*m,*n);
lquery = *lwork == -1;
if (*m < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*nrhs < 0) {
*info = -3;
} else if (*lda < f2cmax(1,*m)) {
*info = -5;
} else if (*ldb < f2cmax(1,maxmn)) {
*info = -7;
}
/* Compute workspace */
/* (Note: Comments in the code beginning "Workspace:" describe the */
/* minimal amount of workspace needed at that point in the code, */
/* as well as the preferred amount for good performance. */
/* NB refers to the optimal block size for the immediately */
/* following subroutine, as returned by ILAENV.) */
if (*info == 0) {
minwrk = 1;
maxwrk = 1;
if (minmn > 0) {
mm = *m;
mnthr = ilaenv_(&c__6, "DGELSS", " ", m, n, nrhs, &c_n1, (ftnlen)
6, (ftnlen)1);
if (*m >= *n && *m >= mnthr) {
/* Path 1a - overdetermined, with many more rows than */
/* columns */
/* Compute space needed for DGEQRF */
dgeqrf_(m, n, &a[a_offset], lda, dum, dum, &c_n1, info);
lwork_dgeqrf__ = (integer) dum[0];
/* Compute space needed for DORMQR */
dormqr_("L", "T", m, nrhs, n, &a[a_offset], lda, dum, &b[
b_offset], ldb, dum, &c_n1, info);
lwork_dormqr__ = (integer) dum[0];
mm = *n;
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + lwork_dgeqrf__;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n + lwork_dormqr__;
maxwrk = f2cmax(i__1,i__2);
}
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined */
/* Compute workspace needed for DBDSQR */
/* Computing MAX */
i__1 = 1, i__2 = *n * 5;
bdspac = f2cmax(i__1,i__2);
/* Compute space needed for DGEBRD */
dgebrd_(&mm, n, &a[a_offset], lda, &s[1], dum, dum, dum, dum,
&c_n1, info);
lwork_dgebrd__ = (integer) dum[0];
/* Compute space needed for DORMBR */
dormbr_("Q", "L", "T", &mm, nrhs, n, &a[a_offset], lda, dum, &
b[b_offset], ldb, dum, &c_n1, info);
lwork_dormbr__ = (integer) dum[0];
/* Compute space needed for DORGBR */
dorgbr_("P", n, n, n, &a[a_offset], lda, dum, dum, &c_n1,
info);
lwork_dorgbr__ = (integer) dum[0];
/* Compute total workspace needed */
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + lwork_dgebrd__;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + lwork_dormbr__;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * 3 + lwork_dorgbr__;
maxwrk = f2cmax(i__1,i__2);
maxwrk = f2cmax(maxwrk,bdspac);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * *nrhs;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = *n * 3 + mm, i__2 = *n * 3 + *nrhs, i__1 = f2cmax(i__1,
i__2);
minwrk = f2cmax(i__1,bdspac);
maxwrk = f2cmax(minwrk,maxwrk);
}
if (*n > *m) {
/* Compute workspace needed for DBDSQR */
/* Computing MAX */
i__1 = 1, i__2 = *m * 5;
bdspac = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = *m * 3 + *nrhs, i__2 = *m * 3 + *n, i__1 = f2cmax(i__1,
i__2);
minwrk = f2cmax(i__1,bdspac);
if (*n >= mnthr) {
/* Path 2a - underdetermined, with many more columns */
/* than rows */
/* Compute space needed for DGELQF */
dgelqf_(m, n, &a[a_offset], lda, dum, dum, &c_n1, info);
lwork_dgelqf__ = (integer) dum[0];
/* Compute space needed for DGEBRD */
dgebrd_(m, m, &a[a_offset], lda, &s[1], dum, dum, dum,
dum, &c_n1, info);
lwork_dgebrd__ = (integer) dum[0];
/* Compute space needed for DORMBR */
dormbr_("Q", "L", "T", m, nrhs, n, &a[a_offset], lda, dum,
&b[b_offset], ldb, dum, &c_n1, info);
lwork_dormbr__ = (integer) dum[0];
/* Compute space needed for DORGBR */
dorgbr_("P", m, m, m, &a[a_offset], lda, dum, dum, &c_n1,
info);
lwork_dorgbr__ = (integer) dum[0];
/* Compute space needed for DORMLQ */
dormlq_("L", "T", n, nrhs, m, &a[a_offset], lda, dum, &b[
b_offset], ldb, dum, &c_n1, info);
lwork_dormlq__ = (integer) dum[0];
/* Compute total workspace needed */
maxwrk = *m + lwork_dgelqf__;
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) +
lwork_dgebrd__;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) +
lwork_dormbr__;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 2) +
lwork_dorgbr__;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + *m + bdspac;
maxwrk = f2cmax(i__1,i__2);
if (*nrhs > 1) {
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + *m + *m * *nrhs;
maxwrk = f2cmax(i__1,i__2);
} else {
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * *m + (*m << 1);
maxwrk = f2cmax(i__1,i__2);
}
/* Computing MAX */
i__1 = maxwrk, i__2 = *m + lwork_dormlq__;
maxwrk = f2cmax(i__1,i__2);
} else {
/* Path 2 - underdetermined */
/* Compute space needed for DGEBRD */
dgebrd_(m, n, &a[a_offset], lda, &s[1], dum, dum, dum,
dum, &c_n1, info);
lwork_dgebrd__ = (integer) dum[0];
/* Compute space needed for DORMBR */
dormbr_("Q", "L", "T", m, nrhs, m, &a[a_offset], lda, dum,
&b[b_offset], ldb, dum, &c_n1, info);
lwork_dormbr__ = (integer) dum[0];
/* Compute space needed for DORGBR */
dorgbr_("P", m, n, m, &a[a_offset], lda, dum, dum, &c_n1,
info);
lwork_dorgbr__ = (integer) dum[0];
maxwrk = *m * 3 + lwork_dgebrd__;
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + lwork_dormbr__;
maxwrk = f2cmax(i__1,i__2);
/* Computing MAX */
i__1 = maxwrk, i__2 = *m * 3 + lwork_dorgbr__;
maxwrk = f2cmax(i__1,i__2);
maxwrk = f2cmax(maxwrk,bdspac);
/* Computing MAX */
i__1 = maxwrk, i__2 = *n * *nrhs;
maxwrk = f2cmax(i__1,i__2);
}
}
maxwrk = f2cmax(minwrk,maxwrk);
}
work[1] = (doublereal) maxwrk;
if (*lwork < minwrk && ! lquery) {
*info = -12;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DGELSS", &i__1, (ftnlen)6);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*m == 0 || *n == 0) {
*rank = 0;
return 0;
}
/* Get machine parameters */
eps = dlamch_("P");
sfmin = dlamch_("S");
smlnum = sfmin / eps;
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
/* Scale A if f2cmax element outside range [SMLNUM,BIGNUM] */
anrm = dlange_("M", m, n, &a[a_offset], lda, &work[1]);
iascl = 0;
if (anrm > 0. && anrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
dlascl_("G", &c__0, &c__0, &anrm, &smlnum, m, n, &a[a_offset], lda,
info);
iascl = 1;
} else if (anrm > bignum) {
/* Scale matrix norm down to BIGNUM */
dlascl_("G", &c__0, &c__0, &anrm, &bignum, m, n, &a[a_offset], lda,
info);
iascl = 2;
} else if (anrm == 0.) {
/* Matrix all zero. Return zero solution. */
i__1 = f2cmax(*m,*n);
dlaset_("F", &i__1, nrhs, &c_b46, &c_b46, &b[b_offset], ldb);
dlaset_("F", &minmn, &c__1, &c_b46, &c_b46, &s[1], &minmn);
*rank = 0;
goto L70;
}
/* Scale B if f2cmax element outside range [SMLNUM,BIGNUM] */
bnrm = dlange_("M", m, nrhs, &b[b_offset], ldb, &work[1]);
ibscl = 0;
if (bnrm > 0. && bnrm < smlnum) {
/* Scale matrix norm up to SMLNUM */
dlascl_("G", &c__0, &c__0, &bnrm, &smlnum, m, nrhs, &b[b_offset], ldb,
info);
ibscl = 1;
} else if (bnrm > bignum) {
/* Scale matrix norm down to BIGNUM */
dlascl_("G", &c__0, &c__0, &bnrm, &bignum, m, nrhs, &b[b_offset], ldb,
info);
ibscl = 2;
}
/* Overdetermined case */
if (*m >= *n) {
/* Path 1 - overdetermined or exactly determined */
mm = *m;
if (*m >= mnthr) {
/* Path 1a - overdetermined, with many more rows than columns */
mm = *n;
itau = 1;
iwork = itau + *n;
/* Compute A=Q*R */
/* (Workspace: need 2*N, prefer N+N*NB) */
i__1 = *lwork - iwork + 1;
dgeqrf_(m, n, &a[a_offset], lda, &work[itau], &work[iwork], &i__1,
info);
/* Multiply B by transpose(Q) */
/* (Workspace: need N+NRHS, prefer N+NRHS*NB) */
i__1 = *lwork - iwork + 1;
dormqr_("L", "T", m, nrhs, n, &a[a_offset], lda, &work[itau], &b[
b_offset], ldb, &work[iwork], &i__1, info);
/* Zero out below R */
if (*n > 1) {
i__1 = *n - 1;
i__2 = *n - 1;
dlaset_("L", &i__1, &i__2, &c_b46, &c_b46, &a[a_dim1 + 2],
lda);
}
}
ie = 1;
itauq = ie + *n;
itaup = itauq + *n;
iwork = itaup + *n;
/* Bidiagonalize R in A */
/* (Workspace: need 3*N+MM, prefer 3*N+(MM+N)*NB) */
i__1 = *lwork - iwork + 1;
dgebrd_(&mm, n, &a[a_offset], lda, &s[1], &work[ie], &work[itauq], &
work[itaup], &work[iwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors of R */
/* (Workspace: need 3*N+NRHS, prefer 3*N+NRHS*NB) */
i__1 = *lwork - iwork + 1;
dormbr_("Q", "L", "T", &mm, nrhs, n, &a[a_offset], lda, &work[itauq],
&b[b_offset], ldb, &work[iwork], &i__1, info);
/* Generate right bidiagonalizing vectors of R in A */
/* (Workspace: need 4*N-1, prefer 3*N+(N-1)*NB) */
i__1 = *lwork - iwork + 1;
dorgbr_("P", n, n, n, &a[a_offset], lda, &work[itaup], &work[iwork], &
i__1, info);
iwork = ie + *n;
/* Perform bidiagonal QR iteration */
/* multiply B by transpose of left singular vectors */
/* compute right singular vectors in A */
/* (Workspace: need BDSPAC) */
dbdsqr_("U", n, n, &c__0, nrhs, &s[1], &work[ie], &a[a_offset], lda,
dum, &c__1, &b[b_offset], ldb, &work[iwork], info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values */
/* Computing MAX */
d__1 = *rcond * s[1];
thr = f2cmax(d__1,sfmin);
if (*rcond < 0.) {
/* Computing MAX */
d__1 = eps * s[1];
thr = f2cmax(d__1,sfmin);
}
*rank = 0;
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
if (s[i__] > thr) {
drscl_(nrhs, &s[i__], &b[i__ + b_dim1], ldb);
++(*rank);
} else {
dlaset_("F", &c__1, nrhs, &c_b46, &c_b46, &b[i__ + b_dim1],
ldb);
}
/* L10: */
}
/* Multiply B by right singular vectors */
/* (Workspace: need N, prefer N*NRHS) */
if (*lwork >= *ldb * *nrhs && *nrhs > 1) {
dgemm_("T", "N", n, nrhs, n, &c_b79, &a[a_offset], lda, &b[
b_offset], ldb, &c_b46, &work[1], ldb);
dlacpy_("G", n, nrhs, &work[1], ldb, &b[b_offset], ldb)
;
} else if (*nrhs > 1) {
chunk = *lwork / *n;
i__1 = *nrhs;
i__2 = chunk;
for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
/* Computing MIN */
i__3 = *nrhs - i__ + 1;
bl = f2cmin(i__3,chunk);
dgemm_("T", "N", n, &bl, n, &c_b79, &a[a_offset], lda, &b[i__
* b_dim1 + 1], ldb, &c_b46, &work[1], n);
dlacpy_("G", n, &bl, &work[1], n, &b[i__ * b_dim1 + 1], ldb);
/* L20: */
}
} else {
dgemv_("T", n, n, &c_b79, &a[a_offset], lda, &b[b_offset], &c__1,
&c_b46, &work[1], &c__1);
dcopy_(n, &work[1], &c__1, &b[b_offset], &c__1);
}
} else /* if(complicated condition) */ {
/* Computing MAX */
i__2 = *m, i__1 = (*m << 1) - 4, i__2 = f2cmax(i__2,i__1), i__2 = f2cmax(
i__2,*nrhs), i__1 = *n - *m * 3;
if (*n >= mnthr && *lwork >= (*m << 2) + *m * *m + f2cmax(i__2,i__1)) {
/* Path 2a - underdetermined, with many more columns than rows */
/* and sufficient workspace for an efficient algorithm */
ldwork = *m;
/* Computing MAX */
/* Computing MAX */
i__3 = *m, i__4 = (*m << 1) - 4, i__3 = f2cmax(i__3,i__4), i__3 =
f2cmax(i__3,*nrhs), i__4 = *n - *m * 3;
i__2 = (*m << 2) + *m * *lda + f2cmax(i__3,i__4), i__1 = *m * *lda +
*m + *m * *nrhs;
if (*lwork >= f2cmax(i__2,i__1)) {
ldwork = *lda;
}
itau = 1;
iwork = *m + 1;
/* Compute A=L*Q */
/* (Workspace: need 2*M, prefer M+M*NB) */
i__2 = *lwork - iwork + 1;
dgelqf_(m, n, &a[a_offset], lda, &work[itau], &work[iwork], &i__2,
info);
il = iwork;
/* Copy L to WORK(IL), zeroing out above it */
dlacpy_("L", m, m, &a[a_offset], lda, &work[il], &ldwork);
i__2 = *m - 1;
i__1 = *m - 1;
dlaset_("U", &i__2, &i__1, &c_b46, &c_b46, &work[il + ldwork], &
ldwork);
ie = il + ldwork * *m;
itauq = ie + *m;
itaup = itauq + *m;
iwork = itaup + *m;
/* Bidiagonalize L in WORK(IL) */
/* (Workspace: need M*M+5*M, prefer M*M+4*M+2*M*NB) */
i__2 = *lwork - iwork + 1;
dgebrd_(m, m, &work[il], &ldwork, &s[1], &work[ie], &work[itauq],
&work[itaup], &work[iwork], &i__2, info);
/* Multiply B by transpose of left bidiagonalizing vectors of L */
/* (Workspace: need M*M+4*M+NRHS, prefer M*M+4*M+NRHS*NB) */
i__2 = *lwork - iwork + 1;
dormbr_("Q", "L", "T", m, nrhs, m, &work[il], &ldwork, &work[
itauq], &b[b_offset], ldb, &work[iwork], &i__2, info);
/* Generate right bidiagonalizing vectors of R in WORK(IL) */
/* (Workspace: need M*M+5*M-1, prefer M*M+4*M+(M-1)*NB) */
i__2 = *lwork - iwork + 1;
dorgbr_("P", m, m, m, &work[il], &ldwork, &work[itaup], &work[
iwork], &i__2, info);
iwork = ie + *m;
/* Perform bidiagonal QR iteration, */
/* computing right singular vectors of L in WORK(IL) and */
/* multiplying B by transpose of left singular vectors */
/* (Workspace: need M*M+M+BDSPAC) */
dbdsqr_("U", m, m, &c__0, nrhs, &s[1], &work[ie], &work[il], &
ldwork, &a[a_offset], lda, &b[b_offset], ldb, &work[iwork]
, info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values */
/* Computing MAX */
d__1 = *rcond * s[1];
thr = f2cmax(d__1,sfmin);
if (*rcond < 0.) {
/* Computing MAX */
d__1 = eps * s[1];
thr = f2cmax(d__1,sfmin);
}
*rank = 0;
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
if (s[i__] > thr) {
drscl_(nrhs, &s[i__], &b[i__ + b_dim1], ldb);
++(*rank);
} else {
dlaset_("F", &c__1, nrhs, &c_b46, &c_b46, &b[i__ + b_dim1]
, ldb);
}
/* L30: */
}
iwork = ie;
/* Multiply B by right singular vectors of L in WORK(IL) */
/* (Workspace: need M*M+2*M, prefer M*M+M+M*NRHS) */
if (*lwork >= *ldb * *nrhs + iwork - 1 && *nrhs > 1) {
dgemm_("T", "N", m, nrhs, m, &c_b79, &work[il], &ldwork, &b[
b_offset], ldb, &c_b46, &work[iwork], ldb);
dlacpy_("G", m, nrhs, &work[iwork], ldb, &b[b_offset], ldb);
} else if (*nrhs > 1) {
chunk = (*lwork - iwork + 1) / *m;
i__2 = *nrhs;
i__1 = chunk;
for (i__ = 1; i__1 < 0 ? i__ >= i__2 : i__ <= i__2; i__ +=
i__1) {
/* Computing MIN */
i__3 = *nrhs - i__ + 1;
bl = f2cmin(i__3,chunk);
dgemm_("T", "N", m, &bl, m, &c_b79, &work[il], &ldwork, &
b[i__ * b_dim1 + 1], ldb, &c_b46, &work[iwork], m);
dlacpy_("G", m, &bl, &work[iwork], m, &b[i__ * b_dim1 + 1]
, ldb);
/* L40: */
}
} else {
dgemv_("T", m, m, &c_b79, &work[il], &ldwork, &b[b_dim1 + 1],
&c__1, &c_b46, &work[iwork], &c__1);
dcopy_(m, &work[iwork], &c__1, &b[b_dim1 + 1], &c__1);
}
/* Zero out below first M rows of B */
i__1 = *n - *m;
dlaset_("F", &i__1, nrhs, &c_b46, &c_b46, &b[*m + 1 + b_dim1],
ldb);
iwork = itau + *m;
/* Multiply transpose(Q) by B */
/* (Workspace: need M+NRHS, prefer M+NRHS*NB) */
i__1 = *lwork - iwork + 1;
dormlq_("L", "T", n, nrhs, m, &a[a_offset], lda, &work[itau], &b[
b_offset], ldb, &work[iwork], &i__1, info);
} else {
/* Path 2 - remaining underdetermined cases */
ie = 1;
itauq = ie + *m;
itaup = itauq + *m;
iwork = itaup + *m;
/* Bidiagonalize A */
/* (Workspace: need 3*M+N, prefer 3*M+(M+N)*NB) */
i__1 = *lwork - iwork + 1;
dgebrd_(m, n, &a[a_offset], lda, &s[1], &work[ie], &work[itauq], &
work[itaup], &work[iwork], &i__1, info);
/* Multiply B by transpose of left bidiagonalizing vectors */
/* (Workspace: need 3*M+NRHS, prefer 3*M+NRHS*NB) */
i__1 = *lwork - iwork + 1;
dormbr_("Q", "L", "T", m, nrhs, n, &a[a_offset], lda, &work[itauq]
, &b[b_offset], ldb, &work[iwork], &i__1, info);
/* Generate right bidiagonalizing vectors in A */
/* (Workspace: need 4*M, prefer 3*M+M*NB) */
i__1 = *lwork - iwork + 1;
dorgbr_("P", m, n, m, &a[a_offset], lda, &work[itaup], &work[
iwork], &i__1, info);
iwork = ie + *m;
/* Perform bidiagonal QR iteration, */
/* computing right singular vectors of A in A and */
/* multiplying B by transpose of left singular vectors */
/* (Workspace: need BDSPAC) */
dbdsqr_("L", m, n, &c__0, nrhs, &s[1], &work[ie], &a[a_offset],
lda, dum, &c__1, &b[b_offset], ldb, &work[iwork], info);
if (*info != 0) {
goto L70;
}
/* Multiply B by reciprocals of singular values */
/* Computing MAX */
d__1 = *rcond * s[1];
thr = f2cmax(d__1,sfmin);
if (*rcond < 0.) {
/* Computing MAX */
d__1 = eps * s[1];
thr = f2cmax(d__1,sfmin);
}
*rank = 0;
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
if (s[i__] > thr) {
drscl_(nrhs, &s[i__], &b[i__ + b_dim1], ldb);
++(*rank);
} else {
dlaset_("F", &c__1, nrhs, &c_b46, &c_b46, &b[i__ + b_dim1]
, ldb);
}
/* L50: */
}
/* Multiply B by right singular vectors of A */
/* (Workspace: need N, prefer N*NRHS) */
if (*lwork >= *ldb * *nrhs && *nrhs > 1) {
dgemm_("T", "N", n, nrhs, m, &c_b79, &a[a_offset], lda, &b[
b_offset], ldb, &c_b46, &work[1], ldb);
dlacpy_("F", n, nrhs, &work[1], ldb, &b[b_offset], ldb);
} else if (*nrhs > 1) {
chunk = *lwork / *n;
i__1 = *nrhs;
i__2 = chunk;
for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ +=
i__2) {
/* Computing MIN */
i__3 = *nrhs - i__ + 1;
bl = f2cmin(i__3,chunk);
dgemm_("T", "N", n, &bl, m, &c_b79, &a[a_offset], lda, &b[
i__ * b_dim1 + 1], ldb, &c_b46, &work[1], n);
dlacpy_("F", n, &bl, &work[1], n, &b[i__ * b_dim1 + 1],
ldb);
/* L60: */
}
} else {
dgemv_("T", m, n, &c_b79, &a[a_offset], lda, &b[b_offset], &
c__1, &c_b46, &work[1], &c__1);
dcopy_(n, &work[1], &c__1, &b[b_offset], &c__1);
}
}
}
/* Undo scaling */
if (iascl == 1) {
dlascl_("G", &c__0, &c__0, &anrm, &smlnum, n, nrhs, &b[b_offset], ldb,
info);
dlascl_("G", &c__0, &c__0, &smlnum, &anrm, &minmn, &c__1, &s[1], &
minmn, info);
} else if (iascl == 2) {
dlascl_("G", &c__0, &c__0, &anrm, &bignum, n, nrhs, &b[b_offset], ldb,
info);
dlascl_("G", &c__0, &c__0, &bignum, &anrm, &minmn, &c__1, &s[1], &
minmn, info);
}
if (ibscl == 1) {
dlascl_("G", &c__0, &c__0, &smlnum, &bnrm, n, nrhs, &b[b_offset], ldb,
info);
} else if (ibscl == 2) {
dlascl_("G", &c__0, &c__0, &bignum, &bnrm, n, nrhs, &b[b_offset], ldb,
info);
}
L70:
work[1] = (doublereal) maxwrk;
return 0;
/* End of DGELSS */
} /* dgelss_ */
|
the_stack_data/96684.c | #ifdef DEV_OFFLINE_LOG_ENABLE
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <hal/soc/flash.h>
#include "iotx_system.h"
#include "iot_import.h"
#include "iot_export.h"
#include "iotx_utils.h"
#include "awss_cmp.h"
#include "awss_packet.h"
#include "zconfig_utils.h"
#include "dev_errcode.h"
#include "dev_diagnosis_log.h"
#include "diagnosis_offline_log.h"
#include "iot_export_diagnosis.h"
#define CRC32_SEED 0xFFFFFFFF
#define POLY32 0x04C11DB7
#define MEM_FLAG "offline.log"
#define OFFLINE_LOG_MALLOC(size) LITE_malloc(size, MEM_MAGIC, MEM_FLAG)
#define OFFLINE_LOG_FREE(ptr) LITE_free(ptr)
#define RESPONSE_ID "id"
#define RESPONSE_CODE "code"
#define RESPONSE_MESSAGE "message"
#define RESPONSE_METHOD "method"
static diagnosis_offline_log_t *p_log_ctx = NULL;
static void *upload_mem_timer = NULL;
static void *oll_working_timer = NULL;
static oll_status_e oll_status = OLL_UNINITED;
static char no_mem_err[] = "no mem";
static uint32_t last_state_msg_crc = 0;
static int offline_log_http_upload(int index, char *payload, int payload_len);
extern int mbedtls_base64_encode(unsigned char *dst, size_t dlen, size_t *olen,
const unsigned char *src, size_t slen);
static int log_flash_read(uint32_t pos, void *buf, size_t nbytes)
{
uint32_t offset = pos;
return hal_flash_read((hal_partition_t)OFFLINE_LOG_PARTITION, &offset, buf, nbytes);
}
static int log_flash_write(uint32_t pos, const void *buf, size_t nbytes)
{
uint32_t offset = pos;
return hal_flash_write((hal_partition_t)OFFLINE_LOG_PARTITION, &offset, buf, nbytes);
}
static int log_flash_erase(uint32_t pos, uint32_t size)
{
uint32_t offset = pos;
return hal_flash_erase((hal_partition_t)OFFLINE_LOG_PARTITION, offset, size);
}
static uint32_t utils_crc32(uint8_t *buf, uint32_t length)
{
uint8_t i;
uint32_t crc = CRC32_SEED; // Initial value
while (length--)
{
crc ^= (uint32_t)(*buf++) << 24; // crc ^=(uint32_t)(*data)<<24; data++;
for (i = 0; i < 8; ++i)
{
if (crc & 0x80000000)
{
crc = (crc << 1) ^ POLY32;
}
else
{
crc <<= 1;
}
}
}
return crc;
}
static int offline_working_timer_cb(void)
{
diagnosis_offline_log_deinit();
if (oll_working_timer)
{
HAL_Timer_Delete(oll_working_timer);
oll_working_timer = NULL;
}
return 0;
}
int diagnosis_offline_log_init(void)
{
int ret = 0;
if (oll_status == OLL_INITED)
{
diagnosis_warn("inited");
return 0;
}
p_log_ctx = (diagnosis_offline_log_t *)OFFLINE_LOG_MALLOC(sizeof(diagnosis_offline_log_t));
if (!p_log_ctx)
{
diagnosis_err("%s", no_mem_err);
return -1;
}
memset(p_log_ctx, 0, sizeof(diagnosis_offline_log_t));
p_log_ctx->p_log_buffer = (char *)OFFLINE_LOG_MALLOC(LOG_BUFFER_MAX_SIZE); //Malloc for first fragment
if (!p_log_ctx->p_log_buffer)
{
diagnosis_err("%s", no_mem_err);
return -1;
}
p_log_ctx->log_buffer_pos = 0;
memset(p_log_ctx->p_log_buffer, '\0', LOG_BUFFER_MAX_SIZE);
if ((ret = aos_mutex_new(&p_log_ctx->offline_log_mutex)) != 0)
{
diagnosis_err("%s", no_mem_err);
return ret;
}
if (oll_working_timer == NULL)
{
oll_working_timer = HAL_Timer_Create("oll_working", (void (*)(void *))offline_working_timer_cb, NULL);
if (oll_working_timer)
{
HAL_Timer_Stop(oll_working_timer);
HAL_Timer_Start(oll_working_timer, OFFLINE_LOG_WORKING_TIME);
}
}
oll_status = OLL_INITED;
return 0;
}
int diagnosis_offline_log_deinit(void)
{
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL,line:%d", __LINE__);
return -1;
}
if (oll_status == OLL_UNINITED || oll_status == OLL_STOPPED)
{
diagnosis_warn("no init");
return -1;
}
if (aos_mutex_lock(&p_log_ctx->offline_log_mutex, AOS_WAIT_FOREVER) != 0)
{
diagnosis_err("lock fail");
return -1;
}
if (p_log_ctx)
{
if (p_log_ctx->p_log_buffer)
{
OFFLINE_LOG_FREE(p_log_ctx->p_log_buffer);
p_log_ctx->p_log_buffer = NULL;
}
if (upload_mem_timer)
{
HAL_Timer_Stop(upload_mem_timer);
HAL_Timer_Delete(upload_mem_timer);
upload_mem_timer = NULL;
}
if (oll_working_timer)
{
HAL_Timer_Stop(oll_working_timer);
HAL_Timer_Delete(oll_working_timer);
oll_working_timer = NULL;
}
aos_mutex_free(&p_log_ctx->offline_log_mutex);
OFFLINE_LOG_FREE(p_log_ctx);
p_log_ctx = NULL;
}
oll_status = OLL_STOPPED;
diagnosis_info("oll deinited");
return 0;
}
static int offline_log_write_buffer(const char *log_level, const char *fmt, va_list *ap)
{
int writed_len = 0;
char uptime[LOG_HEAD_LEN];
char log_head[LOG_HEAD_LEN];
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL,line:%d", __LINE__);
return -1;
}
#ifdef DO_BASE64_ENCODE_WHEN_NOT_UTF8
unsigned int base64_encode_len = 0;
int base64_encode_buf_len = 0;
char *base64_encode_buf = NULL;
#endif
//flash log mode and has flash log can not write log
if (p_log_ctx->has_flash_log && p_log_ctx->log_mode == UPLOAD_LOG_MODE_FLASH)
{
diagnosis_warn("flash log mode");
return -1;
}
if (p_log_ctx->log_buffer_pos >= LOG_BUFFER_MAX_SIZE - 1)
{
diagnosis_info("offline log buf full");
p_log_ctx->log_buffer_pos = LOG_BUFFER_MAX_SIZE - 1;
return -1;
}
memset(log_head, '\0', sizeof(log_head));
HAL_Snprintf(uptime, LOG_HEAD_LEN, "[%06d]", (unsigned)HAL_UptimeMs());
HAL_Snprintf(log_head, LOG_HEAD_LEN, "%s%s ", uptime, log_level);
if (p_log_ctx->log_buffer_pos + strlen(log_head) > LOG_BUFFER_MAX_SIZE)
{
diagnosis_info("offline log buf is full");
memcpy(p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos, log_head, LOG_BUFFER_MAX_SIZE - 1 - p_log_ctx->log_buffer_pos);
p_log_ctx->log_buffer_pos = LOG_BUFFER_MAX_SIZE - 1;
return -1;
}
memcpy(p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos, log_head, strlen(log_head));
p_log_ctx->log_buffer_pos += strlen(log_head);
writed_len = HAL_Vsnprintf(p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos, LOG_BUFFER_MAX_SIZE - p_log_ctx->log_buffer_pos, fmt, *ap);
#ifdef DO_BASE64_ENCODE_WHEN_NOT_UTF8
if (zconfig_is_utf8(p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos, writed_len) == 0)
{
base64_encode_buf_len = writed_len * 4 / 3 + 4;
base64_encode_buf = OFFLINE_LOG_MALLOC(base64_encode_buf_len);
if (!base64_encode_buf)
{
diagnosis_err("%s", no_mem_err);
return -1;
}
memset(base64_encode_buf, '\0', base64_encode_buf_len);
mbedtls_base64_encode((unsigned char *)base64_encode_buf, base64_encode_buf_len, &base64_encode_len, (unsigned char *)(p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos), writed_len);
memcpy(p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos, base64_encode_buf, base64_encode_len);
OFFLINE_LOG_FREE(base64_encode_buf);
writed_len = base64_encode_len;
diagnosis_info("Len:%d B64:%s\r\n", base64_encode_len, p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos);
}
#endif
if (writed_len > LOG_BUFFER_MAX_SIZE - p_log_ctx->log_buffer_pos)
{
p_log_ctx->log_buffer_pos = LOG_BUFFER_MAX_SIZE - 1;
}
else
{
p_log_ctx->log_buffer_pos += writed_len;
}
return writed_len;
}
int diagnosis_offline_log(log_level_e level, const char *fmt, ...)
{
char *p_level = NULL;
va_list ap;
va_start(ap, fmt);
if (oll_status == OLL_STOPPED)
{
diagnosis_info("oll stopped");
return 0;
}
else if (oll_status == OLL_UNINITED || !p_log_ctx)
{
diagnosis_offline_log_init();
}
if (aos_mutex_lock(&p_log_ctx->offline_log_mutex, AOS_WAIT_FOREVER) != 0)
{
diagnosis_err("lock fail");
return -1;
}
switch (level)
{
case LOG_LEVEL_D:
p_level = "<D>";
break;
case LOG_LEVEL_I:
p_level = "<I>";
break;
case LOG_LEVEL_W:
p_level = "<W>";
break;
case LOG_LEVEL_E:
p_level = "<E>";
break;
default:
p_level = "<I>";
break;
}
offline_log_write_buffer(p_level, fmt, &ap);
va_end(ap);
if (aos_mutex_unlock(&p_log_ctx->offline_log_mutex) != 0)
{
diagnosis_err("unlock fail");
return -1;
}
return 0;
}
int diagnosis_offline_log_save_all(void)
{
if (oll_status == OLL_UNINITED || oll_status == OLL_STOPPED)
{
diagnosis_warn("no init");
return -1;
}
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL");
return -1;
}
if (aos_mutex_lock(&p_log_ctx->offline_log_mutex, AOS_WAIT_FOREVER) != 0)
{
diagnosis_err("lock fail");
return -1;
}
log_flash_erase(0, LOG_BUFFER_MAX_SIZE + sizeof(log_flash_desc_t)); //erase flash before write
log_flash_write(0, p_log_ctx->p_log_buffer, p_log_ctx->log_buffer_pos);
p_log_ctx->log_flash_desc.total_size = p_log_ctx->log_buffer_pos;
p_log_ctx->log_flash_desc.crc = utils_crc32((uint8_t *)p_log_ctx->p_log_buffer, p_log_ctx->log_buffer_pos);
log_flash_write(LOG_BUFFER_MAX_SIZE, &p_log_ctx->log_flash_desc, sizeof(log_flash_desc_t));
if (aos_mutex_unlock(&p_log_ctx->offline_log_mutex) != 0)
{
diagnosis_err("unlock fail");
return -1;
}
diagnosis_info("\nSave Total:%d CRC:0x%x\n", p_log_ctx->log_flash_desc.total_size, p_log_ctx->log_flash_desc.crc);
return 0;
}
int diagnosis_offline_log_erase_flash_desc(void)
{
oll_status_e oll_status_backup = oll_status;
if (!p_log_ctx)
{
diagnosis_err("oll no erase");
return -1;
}
if (oll_status == OLL_UNINITED || oll_status == OLL_STOPPED)
{
diagnosis_offline_log_init();
}
if (aos_mutex_lock(&p_log_ctx->offline_log_mutex, AOS_WAIT_FOREVER) != 0)
{
diagnosis_err("lock fail");
return -1;
}
log_flash_erase(LOG_BUFFER_MAX_SIZE, sizeof(log_flash_desc_t)); //erase flash desc
HAL_SleepMs(200); //Wait flash sync
if (aos_mutex_unlock(&p_log_ctx->offline_log_mutex) != 0)
{
diagnosis_err("unlock fail");
return -1;
}
if (oll_status_backup == OLL_STOPPED)
{
diagnosis_offline_log_deinit();
}
diagnosis_info("oll erase desc");
return 0;
}
static int offline_log_upload_by_http(const char *url, int port, char *request_payload, int request_payload_len, char *response_payload, int response_payload_len)
{
int ret = 0;
httpclient_t http_client;
httpclient_data_t http_client_data;
memset(&http_client, 0, sizeof(httpclient_t));
memset(&http_client_data, 0, sizeof(httpclient_data_t));
http_client.header = "Accept:*/*\r\n";
http_client_data.post_content_type = "application/json;charset=utf-8";
http_client_data.post_buf = request_payload;
http_client_data.post_buf_len = request_payload_len;
http_client_data.response_buf = response_payload;
http_client_data.response_buf_len = response_payload_len;
diagnosis_info("url:%s\r\n oll_payload:%s\r\n", url, request_payload);
ret = httpclient_common(&http_client, url, port, NULL, HTTPCLIENT_POST, HTTP_TIMEOUT, &http_client_data);
return ret;
}
static int offline_log_http_upload(int index, char *payload, int payload_len)
{
int ret = 0;
char *code = NULL;
char *message = NULL;
char *digest = NULL;
char *request_payload = NULL;
char *response_payload = NULL;
unsigned int base64_encode_len = 0;
int base64_encode_buf_len = 0;
char *base64_encode_buf = NULL;
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL,line:%d", __LINE__);
return -1;
}
if (oll_status == OLL_UNINITED || oll_status == OLL_STOPPED)
{
diagnosis_warn("no init");
return -1;
}
base64_encode_buf_len = payload_len * 4 / 3 + 4;
request_payload = (char *)OFFLINE_LOG_MALLOC(base64_encode_buf_len + HTTP_REQUEST_PAYLOAD_LEN);
if (!request_payload)
{
diagnosis_err("%s", no_mem_err);
ret = -1;
goto EXIT;
}
memset(request_payload, '\0', base64_encode_buf_len + HTTP_REQUEST_PAYLOAD_LEN);
response_payload = (char *)OFFLINE_LOG_MALLOC(HTTP_RESPONSE_PAYLOAD_LEN);
if (!response_payload)
{
diagnosis_err("%s", no_mem_err);
ret = -1;
goto EXIT;
}
memset(response_payload, '\0', HTTP_RESPONSE_PAYLOAD_LEN);
digest = OFFLINE_LOG_MALLOC(DIGEST_LEN);
if (!digest)
{
diagnosis_err("%s", no_mem_err);
ret = -1;
goto EXIT;
}
memset(digest, '\0', DIGEST_LEN);
base64_encode_buf = OFFLINE_LOG_MALLOC(base64_encode_buf_len);
if (!base64_encode_buf)
{
diagnosis_err("%s", no_mem_err);
return -1;
}
memset(base64_encode_buf, '\0', base64_encode_buf_len);
#ifdef SUPPORT_TLS
mbedtls_base64_encode((unsigned char *)base64_encode_buf, base64_encode_buf_len, &base64_encode_len, (unsigned char *)payload, payload_len);
#endif
utils_hmac_sha1(base64_encode_buf, strlen(base64_encode_buf), digest, p_log_ctx->token, strlen(p_log_ctx->token));
HAL_Snprintf(request_payload, base64_encode_buf_len + HTTP_REQUEST_PAYLOAD_LEN, REQUEST_PAYLOAD_FMT, p_log_ctx->logName, digest, index, payload_len, base64_encode_buf);
ret = offline_log_upload_by_http(p_log_ctx->httpServerURL, p_log_ctx->port, request_payload, strlen(request_payload), response_payload, HTTP_RESPONSE_PAYLOAD_LEN);
if (ret != 0)
{
diagnosis_err("upload fail:%d", ret);
ret = -1;
goto EXIT;
}
code = LITE_json_value_of(RESPONSE_CODE, response_payload, MEM_MAGIC, MEM_FLAG);
if (strcmp(code, "200"))
{
message = LITE_json_value_of(RESPONSE_MESSAGE, response_payload, MEM_MAGIC, MEM_FLAG);
if (message)
{
diagnosis_err("mesg:%s", message);
}
ret = -1;
}
EXIT:
if (digest)
OFFLINE_LOG_FREE(digest);
if (request_payload)
OFFLINE_LOG_FREE(request_payload);
if (response_payload)
OFFLINE_LOG_FREE(response_payload);
if (code)
OFFLINE_LOG_FREE(code);
if (message)
OFFLINE_LOG_FREE(message);
if (base64_encode_buf)
OFFLINE_LOG_FREE(base64_encode_buf);
return ret;
}
static int offline_log_has_flash_data(void)
{
uint32_t crc32 = 0;
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL,line:%d", __LINE__);
return -1;
}
p_log_ctx->has_flash_log = 0;
log_flash_read(LOG_BUFFER_MAX_SIZE, &p_log_ctx->log_flash_desc, sizeof(log_flash_desc_t));
if (p_log_ctx->log_flash_desc.total_size < LOG_BUFFER_MAX_SIZE)
{
log_flash_read(0, p_log_ctx->p_log_buffer, p_log_ctx->log_flash_desc.total_size);
crc32 = utils_crc32((uint8_t *)p_log_ctx->p_log_buffer, p_log_ctx->log_flash_desc.total_size);
if (p_log_ctx->log_flash_desc.crc == crc32)
{
diagnosis_info("Flash log");
p_log_ctx->has_flash_log = 1;
p_log_ctx->log_buffer_pos = p_log_ctx->log_flash_desc.total_size;
*(p_log_ctx->p_log_buffer + p_log_ctx->log_buffer_pos + 1) = '\0';
}
else
{
diagnosis_err("T:%d Crc1:0x%x Crc2:0x%x", p_log_ctx->log_flash_desc.total_size, p_log_ctx->log_flash_desc.crc, crc32);
}
}
diagnosis_info("Total:%d CRC:0x%x", p_log_ctx->log_flash_desc.total_size, p_log_ctx->log_flash_desc.crc);
return p_log_ctx->has_flash_log;
}
static int offline_log_load_flash_log_to_mem(void)
{
int ret = 0;
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL,line:%d", __LINE__);
return -1;
}
if (aos_mutex_lock(&p_log_ctx->offline_log_mutex, AOS_WAIT_FOREVER) != 0)
{
diagnosis_err("lock fail");
return -1;
}
ret = log_flash_read(0, p_log_ctx->p_log_buffer, p_log_ctx->log_flash_desc.total_size);
if (aos_mutex_unlock(&p_log_ctx->offline_log_mutex) != 0)
{
diagnosis_err("unlock fail");
return -1;
}
return ret;
}
static int offline_log_upload_mem(void)
{
int index = 0;
int need_send_len = 0;
int have_send_len = 0;
int retry_count = 0;
int fragment_count = 0;
char *log_buff = NULL;
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL,line:%d", __LINE__);
return -1;
}
if (!p_log_ctx || oll_status == OLL_STOPPED)
{
diagnosis_warn("oll stopped");
return -1;
}
if (p_log_ctx->log_buffer_pos == 0)
{
diagnosis_warn("no mem log");
return -1;
}
if (aos_mutex_lock(&p_log_ctx->offline_log_mutex, AOS_WAIT_FOREVER) != 0)
{
diagnosis_err("lock fail");
return -1;
}
fragment_count = p_log_ctx->log_buffer_pos / LOG_BUFFER_SIZE;
fragment_count = (p_log_ctx->log_buffer_pos % LOG_BUFFER_SIZE) ? fragment_count + 1 : fragment_count;
log_buff = OFFLINE_LOG_MALLOC(LOG_BUFFER_SIZE + 1);
if (!log_buff)
{
diagnosis_err("%s", no_mem_err);
return -1;
}
while (index < fragment_count && retry_count < UPLOAD_RETRY_MAX_COUNT)
{
memset(log_buff, '\0', LOG_BUFFER_SIZE + 1);
if ((p_log_ctx->log_buffer_pos % LOG_BUFFER_SIZE) && (index == (fragment_count - 1)))
{
need_send_len = p_log_ctx->log_buffer_pos - index * LOG_BUFFER_SIZE;
}
else
{
need_send_len = LOG_BUFFER_SIZE;
}
memcpy(log_buff, p_log_ctx->p_log_buffer + have_send_len, need_send_len);
if (offline_log_http_upload(p_log_ctx->mem_log_index, log_buff, need_send_len) < 0)
{
diagnosis_warn("fail id(%d)", index);
retry_count++;
}
else
{
index++;
p_log_ctx->mem_log_index++;
have_send_len += need_send_len;
}
}
if (index == fragment_count) //Upload success
{
diagnosis_info("Upload mem log success");
p_log_ctx->log_buffer_pos = 0;
}
else if (have_send_len > 0 && have_send_len < p_log_ctx->log_buffer_pos) //Upload some
{
for (index = 0; index < p_log_ctx->log_buffer_pos - have_send_len; index++)
{
*(p_log_ctx->p_log_buffer + index) = *(p_log_ctx->p_log_buffer + have_send_len + index);
}
*(p_log_ctx->p_log_buffer + index) = '\0'; //Add end char
p_log_ctx->log_buffer_pos = p_log_ctx->log_buffer_pos - have_send_len;
}
if (log_buff)
{
OFFLINE_LOG_FREE(log_buff);
}
if (aos_mutex_unlock(&p_log_ctx->offline_log_mutex) != 0)
{
diagnosis_err("unlock fail");
return -1;
}
return 0;
}
static int offline_upload_mem_log_timer_cb(void)
{
offline_log_upload_mem();
if (upload_mem_timer) //restart
{
HAL_Timer_Stop(upload_mem_timer);
HAL_Timer_Start(upload_mem_timer, 2000);
}
return 0;
}
static int offline_log_upload(void)
{
if (oll_status != OLL_INITED)
{
diagnosis_warn("oll uninited");
return -1;
}
if (!p_log_ctx)
{
diagnosis_err("p_log_ctx is NULL,line:%d", __LINE__);
return -1;
}
if (p_log_ctx->log_mode == UPLOAD_LOG_MODE_FLASH && p_log_ctx->has_flash_log)
{
offline_log_load_flash_log_to_mem();
return offline_log_upload_mem();
}
else if (p_log_ctx->log_mode == UPLOAD_LOG_MODE_MEM)
{
if (upload_mem_timer == NULL)
{
upload_mem_timer = HAL_Timer_Create("oll_upload", (void (*)(void *))offline_upload_mem_log_timer_cb, NULL);
}
if (upload_mem_timer)
{
HAL_Timer_Stop(upload_mem_timer);
HAL_Timer_Start(upload_mem_timer, 10);
}
}
else
{
diagnosis_warn("oll no upload");
}
return 0;
}
static int offline_log_get_reply(void *context, int result,
void *userdata, void *remote,
void *message)
{
if (result == 2)
{ /* success */
HAL_SleepMs(1000);
offline_log_upload();
}
else
{
diagnosis_err("log get reply fail");
}
return 0;
}
static int offline_log_finish_reply(void *context, int result,
void *userdata, void *remote,
void *message)
{
int ret = 0;
if (result == 2)
{ /* success */
diagnosis_info("finish offline log");
diagnosis_offline_log_deinit();
}
else
{
diagnosis_err("finish fail");
}
return 0;
}
int diagnosis_offline_log_get(void *ctx, void *resource, void *remote, void *request)
{
int ret = 0;
char *id = NULL;
char *method = NULL;
char *httpServerURL = NULL;
char *logName = NULL;
char *token = NULL;
char *logMode = NULL;
int code = 200;
char *payload = NULL;
int payload_len = 0;
char *reply_payload = NULL;
int is_dynamic_register = 0;
char *digest = NULL;
char *msg = NULL;
char *topic = NULL;
payload = awss_cmp_get_coap_payload(request, &payload_len);
if (!payload || payload_len < 1)
{
diagnosis_err("no pl");
code = RESPONSE_CODE_NO_PAYLOAD;
goto REPLY;
}
diagnosis_info("payload:%s", payload);
id = LITE_json_value_of(RESPONSE_ID, payload, MEM_MAGIC, MEM_FLAG);
if (NULL == id)
{
diagnosis_err("id err");
code = RESPONSE_CODE_PARSE_JSON_FAILED;
goto REPLY;
}
httpServerURL = LITE_json_value_of(PARAMS_HTTPSERVERURL, payload, MEM_MAGIC, MEM_FLAG);
if (NULL == httpServerURL)
{
diagnosis_err("url err");
code = RESPONSE_CODE_PARSE_JSON_FAILED;
goto REPLY;
}
logName = LITE_json_value_of(PARAMS_LOGNAME, payload, MEM_MAGIC, MEM_FLAG);
if (NULL == logName)
{
diagnosis_err("name err");
code = RESPONSE_CODE_PARSE_JSON_FAILED;
goto REPLY;
}
token = LITE_json_value_of(PARAMS_TOKEN, payload, MEM_MAGIC, MEM_FLAG);
if (NULL == token)
{
diagnosis_err("token err");
code = RESPONSE_CODE_PARSE_JSON_FAILED;
goto REPLY;
}
logMode = LITE_json_value_of(PARAMS_LOGMODE, payload, MEM_MAGIC, MEM_FLAG);
if (NULL == logMode)
{
diagnosis_err("logMode err");
code = RESPONSE_CODE_PARSE_JSON_FAILED;
goto REPLY;
}
if (oll_status == OLL_UNINITED || oll_status == OLL_STOPPED || !p_log_ctx)
{
diagnosis_offline_log_init();
}
if (p_log_ctx) //Save data
{
char *host_ptr = (char *)strstr(httpServerURL, "://");
char *path_ptr = NULL;
char *port_ptr = NULL;
char port_buf[PORT_MAX_LEN] = {0};
int port_len = 0;
host_ptr += 3;
port_ptr = strchr(host_ptr, ':');
port_ptr += 1;
path_ptr = strchr(port_ptr, '/');
if (port_ptr && path_ptr)
{
port_len = path_ptr - port_ptr;
if (port_len < PORT_MAX_LEN)
{
memset(port_buf, '\0', PORT_MAX_LEN);
memcpy(port_buf, port_ptr, port_len);
p_log_ctx->port = atoi(port_buf);
}
}
//Allow only one APP connect device
if (strlen(p_log_ctx->httpServerURL) > 0 && strcmp(p_log_ctx->httpServerURL, httpServerURL))
{
diagnosis_warn("being diagnosising");
goto ERROR;
}
memset(p_log_ctx->httpServerURL, '\0', HTTP_SERVER_URL_LEN);
memset(p_log_ctx->logName, '\0', LOG_NAME_LEN);
memset(p_log_ctx->token, '\0', TOKEN_LEN);
strncpy(p_log_ctx->httpServerURL, httpServerURL, strlen(httpServerURL) > (HTTP_SERVER_URL_LEN - 1) ? (HTTP_SERVER_URL_LEN - 1) : strlen(httpServerURL));
strncpy(p_log_ctx->logName, logName, strlen(logName) > (LOG_NAME_LEN - 1) ? (LOG_NAME_LEN - 1) : strlen(logName));
strncpy(p_log_ctx->token, token, strlen(token) > (TOKEN_LEN - 1) ? (TOKEN_LEN - 1) : strlen(token));
p_log_ctx->log_mode = atoi(logMode);
diagnosis_info("logmode:%d", p_log_ctx->log_mode);
}
REPLY:
reply_payload = OFFLINE_LOG_MALLOC(REPLAY_PAYLOAD_LEN);
if (!reply_payload)
{
diagnosis_err("%s", no_mem_err);
goto ERROR;
}
memset(reply_payload, '\0', REPLAY_PAYLOAD_LEN);
if (code == 200)
{
char pk[PRODUCT_KEY_LEN];
char dn[DEVICE_NAME_LEN];
char ps[PRODUCT_SECRET_LEN];
char ds[DEVICE_SECRET_LEN];
HAL_GetProductKey(pk);
HAL_GetProductSecret(ps);
HAL_GetDeviceName(dn);
HAL_GetDeviceSecret(ds);
digest = OFFLINE_LOG_MALLOC(DIGEST_LEN);
if (!digest)
{
diagnosis_err("%s", no_mem_err);
goto ERROR;
}
memset(digest, '\0', DIGEST_LEN);
msg = OFFLINE_LOG_MALLOC(MESSAGE_LEN);
if (!msg)
{
diagnosis_err("%s", no_mem_err);
goto ERROR;
}
memset(msg, '\0', MESSAGE_LEN);
HAL_Snprintf(msg, MESSAGE_LEN, "%s%s%s%s%s%s", "credibleFileName",
p_log_ctx->logName, "deviceName", dn, "productKey", pk);
IOT_Ioctl(IOTX_IOCTL_GET_DYNAMIC_REGISTER, &is_dynamic_register);
if (is_dynamic_register)
{
utils_hmac_sha1(msg, strlen(msg), digest, ps, strlen(ps));
}
else
{
utils_hmac_sha1(msg, strlen(msg), digest, ds, strlen(ds));
}
memset(msg, '\0', MESSAGE_LEN);
if (p_log_ctx->log_mode == UPLOAD_LOG_MODE_FLASH)
{
if (offline_log_has_flash_data())
{
int fragment_count = 0;
fragment_count = p_log_ctx->log_flash_desc.total_size / LOG_BUFFER_SIZE;
fragment_count = (p_log_ctx->log_flash_desc.total_size % LOG_BUFFER_SIZE) ? fragment_count + 1 : fragment_count;
HAL_Snprintf(msg, MESSAGE_LEN, GET_REPLY_DATA_FLASH_FMT, OFFLINE_LOG_VERSION, is_dynamic_register,
digest, 0, p_log_ctx->log_flash_desc.total_size, fragment_count);
}
else
{
HAL_Snprintf(msg, MESSAGE_LEN, GET_REPLY_DATA_FLASH_FMT, OFFLINE_LOG_VERSION, is_dynamic_register,
digest, 0, 0, 0);
}
}
else
{
HAL_Snprintf(msg, MESSAGE_LEN, GET_REPLY_DATA_MEM_FMT, OFFLINE_LOG_VERSION, is_dynamic_register,
digest, 1);
}
HAL_Snprintf(reply_payload, REPLAY_PAYLOAD_LEN, GET_REPLY_FMT, id, code, msg);
}
else
{
HAL_Snprintf(reply_payload, REPLAY_PAYLOAD_LEN, GET_REPLY_FMT, id, code, "{}");
}
diagnosis_info("OLL send to APP:%s", reply_payload);
topic = OFFLINE_LOG_MALLOC(TOPIC_URL_LEN);
if (NULL == topic)
{
diagnosis_err("%s", no_mem_err);
goto ERROR;
}
memset(topic, '\0', TOPIC_URL_LEN);
awss_build_topic((const char *)TOPIC_OFFLINE_LOG_GET_REPLY, topic, TOPIC_URL_LEN);
ret = awss_cmp_coap_send_resp(reply_payload, strlen(reply_payload), remote, topic, request, offline_log_get_reply, NULL, 1);
ERROR:
if (id)
OFFLINE_LOG_FREE(id);
if (reply_payload)
OFFLINE_LOG_FREE(reply_payload);
if (digest)
OFFLINE_LOG_FREE(digest);
if (msg)
OFFLINE_LOG_FREE(msg);
if (topic)
OFFLINE_LOG_FREE(topic);
if (httpServerURL)
OFFLINE_LOG_FREE(httpServerURL);
if (logName)
OFFLINE_LOG_FREE(logName);
if (token)
OFFLINE_LOG_FREE(token);
if (logMode)
OFFLINE_LOG_FREE(logMode);
return (code == 200) ? ret : -1;
}
int diagnosis_offline_log_finish(void *ctx, void *resource, void *remote, void *request)
{
int ret = 0;
char *id = NULL;
char *method = NULL;
int code = 200;
char *topic = NULL;
char *payload = NULL;
int payload_len = 0;
char *reply_payload = NULL;
payload = awss_cmp_get_coap_payload(request, &payload_len);
if (!payload || payload_len < 1)
{
diagnosis_err("no pl");
code = RESPONSE_CODE_NO_PAYLOAD;
goto REPLY;
}
diagnosis_info("payload:%s", payload);
id = LITE_json_value_of(RESPONSE_ID, payload, MEM_MAGIC, MEM_FLAG);
if (NULL == id)
{
diagnosis_err("id err");
code = RESPONSE_CODE_PARSE_JSON_FAILED;
goto REPLY;
}
method = LITE_json_value_of(RESPONSE_METHOD, payload, MEM_MAGIC, MEM_FLAG);
if (NULL == id)
{
diagnosis_err("method err");
code = RESPONSE_CODE_PARSE_JSON_FAILED;
goto REPLY;
}
if (strcmp(method, OFFLINE_LOG_FINISH_METHOD) != 0)
{
diagnosis_err("method not match");
code = RESPONSE_CODE_METHOD_NOT_MATCH;
goto REPLY;
}
REPLY:
reply_payload = OFFLINE_LOG_MALLOC(REPLAY_FINISH_PAYLOAD_LEN);
if (!reply_payload)
{
diagnosis_err("%s", no_mem_err);
return -1;
}
memset(reply_payload, '\0', REPLAY_FINISH_PAYLOAD_LEN);
HAL_Snprintf(reply_payload, REPLAY_FINISH_PAYLOAD_LEN, GET_REPLY_FMT, id, code, "{}");
topic = OFFLINE_LOG_MALLOC(TOPIC_URL_LEN);
if (NULL == topic)
{
diagnosis_err("%s", no_mem_err);
goto ERROR;
}
awss_build_topic((const char *)TOPIC_DEV_OFFLINE_LOG_FINISH_REPLY, topic, TOPIC_URL_LEN);
diagnosis_info("OLL send to APP:%s", reply_payload);
ret = awss_cmp_coap_send_resp(reply_payload, strlen(reply_payload), remote, topic, request, offline_log_finish_reply, NULL, 1);
ERROR:
if (id)
OFFLINE_LOG_FREE(id);
if (method)
OFFLINE_LOG_FREE(method);
if (reply_payload)
OFFLINE_LOG_FREE(reply_payload);
if (topic)
OFFLINE_LOG_FREE(topic);
return (code == 200) ? ret : -1;
}
int diagnosis_offline_log_state_code_handle(const int state_code, const char *state_message)
{
uint16_t err_code = 0;
uint8_t *crc_buff = NULL;
uint32_t crc_len = 0;
uint32_t crc_value = 0;
if (STATE_WIFI_CHAN_SCAN == state_code)
return 0;
crc_len = sizeof(int) + strlen(state_message) + 1;
crc_buff = OFFLINE_LOG_MALLOC(crc_len);
if (!crc_buff)
return -1;
memset(crc_buff, '\0', crc_len);
HAL_Snprintf((char *)crc_buff, crc_len, "%d%s", state_code, state_message);
crc_value = utils_crc32(crc_buff, (unsigned int)strlen((char *)crc_buff));
if (last_state_msg_crc == crc_value) //not save duplicated state msg
{
diagnosis_info("same state msg");
if (crc_buff)
OFFLINE_LOG_FREE(crc_buff);
return 0;
}
last_state_msg_crc = crc_value;
err_code = dev_errcode_sdk_filter(state_code);
if (err_code > 0)
{
if (NULL == state_message)
{
diagnosis_offline_log(LOG_LEVEL_E, "EC(0x%04x) SC(-0x%04x)\r\n", err_code, -state_code);
}
else
{
diagnosis_offline_log(LOG_LEVEL_E, "EC(0x%04x) SC(-0x%04x) SM(%s)\r\n", err_code, -state_code, state_message);
}
}
else
{
if (NULL == state_message)
{
diagnosis_offline_log(LOG_LEVEL_I, "SC(-0x%04x)\r\n", -state_code);
}
else
{
diagnosis_offline_log(LOG_LEVEL_I, "SC(-0x%04x) SM(%s)\r\n", -state_code, state_message);
}
}
if (crc_buff)
OFFLINE_LOG_FREE(crc_buff);
return 0;
}
#ifdef OFFLINE_LOG_UT_TEST
int diagnosis_offline_log_upload(const char *host, int port)
{
if (oll_status == OLL_UNINITED || oll_status == OLL_STOPPED)
{
diagnosis_offline_log_init();
}
if (p_log_ctx)
{
memset(p_log_ctx->httpServerURL, '\0', HTTP_SERVER_URL_LEN);
HAL_Snprintf(p_log_ctx->httpServerURL, HTTP_SERVER_URL_LEN, "%s", host);
p_log_ctx->port = port;
return offline_log_upload();
}
return -1;
}
int diagnosis_offline_log_read_all(upload_log_mode_e log_mode)
{
if (oll_status == OLL_UNINITED || !p_log_ctx)
{
diagnosis_warn("no init");
return -1;
}
if (aos_mutex_lock(&p_log_ctx->offline_log_mutex, AOS_WAIT_FOREVER) != 0)
{
diagnosis_err("lock fail");
return -1;
}
if (UPLOAD_LOG_MODE_MEM == log_mode)
{
if (p_log_ctx && p_log_ctx->log_buffer_pos > 0 && p_log_ctx->p_log_buffer)
{
HAL_Printf("Mem log Size(%d)\r\n%s\r\n", p_log_ctx->log_buffer_pos, p_log_ctx->p_log_buffer);
}
}
else
{
offline_log_has_flash_data();
if (p_log_ctx && p_log_ctx->has_flash_log == 1 && p_log_ctx->log_buffer_pos > 0 && p_log_ctx->p_log_buffer)
{
HAL_Printf("Flash log Size(%d)\r\n%s\r\n", p_log_ctx->log_buffer_pos, p_log_ctx->p_log_buffer);
}
}
if (aos_mutex_unlock(&p_log_ctx->offline_log_mutex) != 0)
{
diagnosis_err("unlock fail");
return -1;
}
return 0;
}
#endif
#endif
|
the_stack_data/23574944.c |
#include <stdio.h>
void scilab_rt_champ1_i2d2d2d2d0i2_(int in00, int in01, int matrixin0[in00][in01],
int in10, int in11, double matrixin1[in10][in11],
int in20, int in21, double matrixin2[in20][in21],
int in30, int in31, double matrixin3[in30][in31],
double scalarin0,
int in40, int in41, int matrixin4[in40][in41])
{
int i;
int j;
int val0 = 0;
double val1 = 0;
double val2 = 0;
double val3 = 0;
int val4 = 0;
for (i = 0; i < in00; ++i) {
for (j = 0; j < in01; ++j) {
val0 += matrixin0[i][j];
}
}
printf("%d", val0);
for (i = 0; i < in10; ++i) {
for (j = 0; j < in11; ++j) {
val1 += matrixin1[i][j];
}
}
printf("%f", val1);
for (i = 0; i < in20; ++i) {
for (j = 0; j < in21; ++j) {
val2 += matrixin2[i][j];
}
}
printf("%f", val2);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%f", val3);
printf("%f", scalarin0);
for (i = 0; i < in40; ++i) {
for (j = 0; j < in41; ++j) {
val4 += matrixin4[i][j];
}
}
printf("%d", val4);
}
|
the_stack_data/9583.c | int N;
#pragma parameter N 8 16
int main()
{
int i, j, a[N], b[N];
#pragma scop
while (1) {
for (j = 0; j < N; ++j)
a[j] = 0;
for (j = 0; j < N; ++j)
b[j] = a[j];
}
#pragma endscop
}
|
the_stack_data/51484.c | /*
* Copyright (c) 2015-2018 Nexenta Systems, inc.
*
* This file is part of EdgeFS Project
* (see https://github.com/Nexenta/edgefs).
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/* IPv6 multicast example - ipv6_multicast_recv.c
2012 - Bjorn Lindgren <[email protected]>
https://github.com/bjornl/ipv6_multicast_example
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
int
main(int argc, char *argv[])
{
struct sockaddr_in6 saddr, maddr;
struct ipv6_mreq mreq;
char buf[140000];
ssize_t len;
int sd, fd, rc, on = 1, flag = 0, hops = 255, ifidx;
struct timeval tv;
fd_set fds;
if (argc < 4) {
printf("\nUsage: %s <address> <port> <netif>\n\nExample: %s ff02::5:6 12345 eth1\n\n", argv[0], argv[0]);
return 1;
}
ifidx = if_nametoindex(argv[3]);
printf("ifidx=%d\n", ifidx);
sd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (sd < 0) {
perror("socket");
return 1;
}
if (setsockopt(sd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on))) {
perror("setsockopt REUSEPORT");
return 1;
}
if (setsockopt(sd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifidx, sizeof(ifidx))) {
perror("setsockopt MULTICAST_IF");
return 1;
}
if (setsockopt(sd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &hops, sizeof(hops))) {
perror("setsockopt HOPS");
return 1;
}
if (setsockopt(sd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &on, sizeof(on))) {
perror("setsockopt LOOP");
return 1;
}
if (setsockopt(sd, IPPROTO_IPV6, IPV6_RECVHOPOPTS, &on, sizeof(on))) {
perror("setsockopt HOPOPTS");
return 1;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin6_family = AF_INET6;
saddr.sin6_port = htons(atoi(argv[2]));;
saddr.sin6_scope_id = ifidx;
// saddr.sin6_addr = in6addr_any;
inet_pton(AF_INET6, argv[1], &maddr.sin6_addr);
if (bind(sd, (struct sockaddr *) &saddr, sizeof(saddr))) {
perror("bind");
return 1;
}
memset(&maddr, 0, sizeof(maddr));
inet_pton(AF_INET6, argv[1], &maddr.sin6_addr);
memcpy(&mreq.ipv6mr_multiaddr, &maddr.sin6_addr, sizeof(mreq.ipv6mr_multiaddr));
mreq.ipv6mr_interface = ifidx;
if (setsockopt(sd, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *) &mreq, sizeof(mreq))) {
perror("setsockopt JOIN_GROUP");
return 1;
}
// len = recv(sd, buf, 140000, 0);
// printf("len=%ld\n", len);
FD_ZERO(&fds);
FD_SET(sd, &fds);
tv.tv_sec = 10;
tv.tv_usec = 0;
fd = open("/dev/stdout", O_WRONLY, NULL);
if (fd < 0) {
perror("open");
return 1;
}
while (1) {
if (flag) {
rc = select(sd + 1, &fds, NULL, NULL, &tv);
if (!rc) {
break;
}
tv.tv_sec = 10;
tv.tv_usec = 0;
}
len = read(sd, buf, 1400);
buf[len] = '\0';
/* printf("Read %zd bytes from sd\n", len); */
if (!len) {
break;
} else if (len < 0) {
perror("read");
return 1;
} else {
len = write(fd, buf, len);
/* printf("wrote %zd bytes to fd\n", len); */
flag++;
}
}
close(sd);
close(fd);
return 0;
}
|
the_stack_data/170452361.c | #include <stdio.h>
int main(void){
const int FREEZING = 0;
float temperature;
int cold_days = 0;
int all_days = 0;
printf("Enter the list of daily low temperatures.\n");
printf("Use Celsius, and enter q to quit.\n");
while (scanf("%f", &temperature) == 1){
all_days++;
if (temperature < FREEZING)
cold_days++;
}
if (all_days != 0)
printf("%d days total: %.1f%%(%d days) were below freezing\n", all_days, 100.0 * (float) cold_days / all_days, cold_days);
return 0;
} |
the_stack_data/68106.c | /*P8.29 Prime numbers using sieve*/
#include<stdio.h>
#define MAX 10000
int main(void)
{
int p,i,n,a[MAX]={0};
printf("Enter n : ");
scanf("%d",&n);
p=2;
while(p*p <= n)
{
for(i=2; i*p<=n; i++) /*Cross out all multiples of p*/
a[i*p]=1;
for(i=p+1; i<=n; i++) /*Find next uncrossed*/
if(a[i]==0)
{
p=i;
break;
}
}
/*Print all uncrossed integers*/
for(i=2; i<=n; i++)
if(a[i]==0)
printf("%d ",i);
return 0;
} |
the_stack_data/175142703.c | /*
* TL;DW
*/
|
the_stack_data/1270207.c | #include <stdio.h>
FILE* setmntent(const char* path, const char* mode) {
return fopen(path, mode);
}
int endmntent(FILE* fp) {
if (fp != NULL) {
fclose(fp);
}
return 1;
}
|
the_stack_data/740707.c | #include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main ( void ) {
int i;
//unsigned seed;
//printf("Digite um numero: ");
//scanf("%u", &seed);
srand(time(NULL));
for(i = 1; i <= 10; i++) {
printf("%4d", 1 + ( rand() % 6 ));
if ( i % 5 == 0 ) {
printf("\n");
}
}
}
|
the_stack_data/237642704.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv) {
if (argc != 2 || (argc == 2 && !strcmp(argv[1], "-h"))) {
printf("Usage: %s <file.bank>\n", argv[0]);
return argc != 2;
}
FILE *fp = fopen(argv[1], "r");
if (!fp) {
printf("Could not open file '%s'\n", argv[1]);
return 1;
}
fseek(fp, 0, SEEK_END);
long ilength = ftell(fp);
if (ilength <= 0) {
printf("Truncated file?\n");
fclose(fp);
return 1;
}
size_t length = ilength;
rewind(fp);
char *buf = malloc(length);
if (!buf) {
printf("Memory allocation failed\n");
fclose(fp);
return 1;
}
if (fread(buf, 1, length, fp) != length) {
printf("Input failure (%s)\n", argv[1]);
fclose(fp);
return 1;
}
fclose(fp);
if (length < 4 || memcmp(buf, "RIFF", 4)) {
printf("Warning: file does not start with a RIFF header. It may not actually be an FMOD bank file.\n");
}
int success = 0;
for (; length >= 4 && !(success=memcmp(buf, "FSB5", 4)); length--, buf++);
if (!success) {
printf("Truncated or bad file?\n");
return 1;
}
size_t l = strlen(argv[1]);
char *ofname;
if (!strcmp(argv[1]+l-5, ".bank")) {
ofname = argv[1];
strcpy(ofname+l-4, "fsb");
} else {
static char fbuf[512];
snprintf(fbuf, sizeof(fbuf), "%s.fsb", argv[1]);
ofname = fbuf;
}
FILE *ofp = fopen(ofname, "w");
if (!ofp) {
printf("Could not create file '%s'\n", ofname);
return 1;
}
if (fwrite(buf, 1, length, ofp) != length) {
printf("Output failure (%s)\n", ofname);
return 1;
}
printf("All done! Your file is in '%s'.\n", ofname);
}
|
the_stack_data/1030055.c | const unsigned char gImage_chooseCell[4736] = { /* 0X41,0X01,0X28,0X01,0X80,0X00, */
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XBD,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X80,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XBF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X9D,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XAE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XDD,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFE,0XE3,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFC,0XC9,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XDD,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XE7,0XFD,0XDD,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XEB,0XFC,0X99,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XED,0XFE,0X3B,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X80,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XEF,0XFE,0X1F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFC,0X8F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XAF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XAF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFC,0X8F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFE,0X9F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XEE,0X1F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XCC,0XCF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XDD,0XEF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XD0,0XDD,0XEF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XCC,0XCF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XE0,0X1F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XCE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XFB,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XF9,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFC,0X01,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFD,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC1,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XCD,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X86,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XF2,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XF8,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XBD,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X80,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XBF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X9D,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XAE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XDD,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFE,0XE3,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFC,0XC9,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XDD,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XDD,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XE7,0XFC,0X99,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XEB,0XFE,0X3B,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XED,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X80,0XFE,0X1F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XEF,0XFC,0X8F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XAF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XAF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFC,0X8F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFE,0X9F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XEE,0X1F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XCC,0XCF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XDD,0XEF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XDD,0XEF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XD0,0XCC,0XCF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XE0,0X1F,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XCE,0XFC,0XF3,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFC,0X79,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0X3D,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0X9D,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFD,0XC9,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFD,0XE3,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC1,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XCD,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0X86,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XF2,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XF8,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XB6,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XC9,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XBF,0XFF,0XFE,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0X80,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,
};
|
the_stack_data/61075406.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
int arr[100];
char array1[100];
char array[100];
scanf("%s",array);
scanf("%s",array1);
int target = atoi(array1);
int m=0;
for(m=0; array[m]; m++) {
if(array[m] != ' ') {
arr[m]=array[m]-'0';
}
}
int sum=0;
int flag=0;
if(m == 2){
sum = arr[0]+arr[1];
sum = arr[0] - arr[1];
if(flag == 0 ){
printf("-1\n");
}
}
if(m == 3){
sum = arr[0]+arr[1] + arr[2];
if(sum == target){
printf("%d+%d+%d=%d\n",arr[0],arr[1],arr[2],sum);
flag=1;
}
sum = arr[0] - arr[1] + arr[2];
if(sum == target){
printf("%d+%d+%d=%d\n",arr[0],arr[1],arr[2],sum);
flag=1;
}
sum = arr[0] + arr[1] -arr[2];
if(sum == target){
printf("%d+%d-%d=%d\n",arr[0],arr[1],arr[2],sum);
flag=1;
}
sum = arr[0] - arr[1] -arr[2];
if(sum == target){
printf("%d-%d-%d=%d\n",arr[0],arr[1],arr[2],sum);
flag=1;
}
if(flag == 0){
printf("-1\n");
}
}
if(m == 4){
sum = arr[0]+arr[1] + arr[2]+ arr[3];
if(sum == target){
printf("%d+%d+%d+%d=%d\n",arr[0],arr[1],arr[2],arr[3],sum);
flag=1;
}
sum = arr[0] - arr[1] - arr[2] + arr[3];
if(sum == target){
flag=1;
printf("%d-%d-%d+%d=%d\n",arr[0],arr[1],arr[2],arr[3],sum);
}
sum = arr[0] + arr[1] +arr[2] - arr[3];
if(sum == target){
flag=1;
printf("%d+%d+%d-%d=%d\n",arr[0],arr[1],arr[2],arr[3],sum);
}
sum = arr[0] + arr[1] - arr[2] - arr[3];
if(sum == target){
flag=1;
printf("%d+%d-%d-%d=%d\n",arr[0],arr[1],arr[2],arr[3],sum);
}
sum = arr[0] - arr[1] + arr[2] - arr[3];
if(sum == target){
flag=1;
printf("%d-%d+%d-%d=%d\n",arr[0],arr[1],arr[2],arr[3],sum);
}
if(flag ==0 ){
printf("-1\n");
}
}
if(m == 5){
sum = arr[0]+arr[1] + arr[2]+ arr[3]+ arr[4];
if(sum == target){
flag=1;
printf("%d+%d+%d+%d+%d=%d\n",arr[0],arr[1],arr[2],arr[3],arr[4],sum);
}
sum = arr[0] + arr[1] - arr[2] + arr[3]+arr[4];
if(sum == target){
flag=1;
printf("%d-%d-%d+%d+%d=%d\n",arr[0],arr[1],arr[2],arr[3],arr[4],sum);
}
sum = arr[0] + arr[1] +arr[2] + arr[3] - arr[4];
if(sum == target){
flag=1;
printf("%d+%d+%d+%d-%d=%d\n",arr[0],arr[1],arr[2],arr[3],arr[4],sum);
}
sum = arr[0] - arr[1] - arr[2] + arr[3] + arr[4];
if(sum == target){
flag=1;
printf("%d-%d-%d+%d+%d=%d\n",arr[0],arr[1],arr[2],arr[3],arr[4],sum);
}
sum = arr[0] - arr[1] + arr[2] - arr[3] + arr[4];
if(sum == target){
flag=1;
printf("%d-%d+%d-%d+%d=%d\n",arr[0],arr[1],arr[2],arr[3],arr[4],sum);
}
if(flag == 0){
printf("-1\n");
}
}
return 0;
}
|
the_stack_data/88440.c | #include <stdio.h>
#include <string.h>
int main()
{
char aux; int convert, inverso;
int linhas, repeat; scanf("%d", &linhas);
char string[linhas][110];
for (repeat = 0; repeat < linhas; repeat ++)
{
getchar();
scanf("%[^\n]", string[repeat]);
}
for (repeat = 0; repeat < linhas; repeat ++)
{
for (convert = 0; convert < strlen(string[repeat]); convert ++)
{
if (string[repeat][convert] > 64 && !(string[repeat][convert] > 90 && string[repeat][convert] < 97)
&& string[repeat][convert] < 123)
{
string[repeat][convert] += 3;
}
}
for (convert = strlen(string[repeat]) - 1, inverso = 0; inverso < convert; convert --, inverso ++)
{
aux = string[repeat][inverso];
string[repeat][inverso] = string[repeat][convert];
string[repeat][convert] = aux;
}
for (convert = (strlen(string[repeat]) / 2); convert < strlen(string[repeat]); convert ++)
{
string[repeat][convert] -= 1;
}
}
for (repeat = 0; repeat < linhas; repeat ++)
{
printf("%s\n", string[repeat]);
}
return(0);
}
//Até 64
|
the_stack_data/146079.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define BUFF 25
int main(int argc, char *argv[]) {
FILE *arq;
arq = fopen(argv[1],"r");
char senha[BUFF + 25];
char comp[BUFF + 75];
char *result;
char salt[BUFF];
printf("Digite a Hash: ");
scanf("%s",&comp);
printf("Digite o Salt: ");
scanf("%s",&salt);
int test = 0;
while(fscanf(arq, "%s", &senha) != EOF) {
result = (char *) crypt(senha,salt);
if (strcmp(comp,result)==0) {
printf("Senha Encontrada: %s \n",senha);
test=1;
return(0);
} else {
test=0;
}
}
if (test == 0) {
printf("Unhash Fail!\n");
}
}
|
the_stack_data/1153731.c | #include<stdio.h>
#include<math.h>
#include<assert.h>
int is_prime(int x){
int i, m;
assert(x >= 0);
if(x == 1) return 0;
m = floor(sqrt(x) + 0.5);
for(i = 2; i <= m; i++)
if(x % i == 0) return 0;
return 1;
}
int main(){
int i, m;
scanf("%d", &m);
for(i = m-2; i >= 3; i--)
if(is_prime(i) && is_prime(i+2)) {
printf("%d %d\n", i, i+2);
break;
}
return 0;
}
|
the_stack_data/178264374.c | // 计算多项式的值
#include <stdio.h>
int main() {
float x;
printf("请输入x的值: \n");
scanf("%f", &x);
printf("多项式的值为: %f\n", 3 * x * x * x * x * x + 2 * x * x * x * x -
5 * x * x * x - x * x + 7 * x - 6);
return 0;
}
|
the_stack_data/877938.c | /*
* Copyright (C) 2014, Galois, Inc.
* This sotware is distributed under a standard, three-clause BSD license.
* Please see the file LICENSE, distributed with this software, for specific
* terms and conditions.
*/
#include <unistd.h>
#include <stdio.h>
gid_t getgid(void)
{
printf("getgid\n");
return 0xaffab1e;
}
|
the_stack_data/67325946.c | /* Exercise 1 - Calculations
Write a C program to input marks of two subjects. Calculate and print the average of the two marks. */
#include <stdio.h>
int main() {
int mark1,mark2;
float average = 0;
printf("enter mark 1 : ");
scanf("%d",&mark1);
printf("enter mark 2 : ");
scanf("%d",&mark2);
average = (mark1+mark2)/2;
printf("display average : %.2f",average);
return 0;
}
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.