file
stringlengths 18
26
| data
stringlengths 3
1.04M
|
|---|---|
the_stack_data/82951262.c | /*
* pcb.c
*
* Created on: Feb 9, 2020
* Author: marwankhan
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct PCB {
int PC;
int pID;
int pageTable[10];
int PC_page;
int PC_offset;
int pages_max;
struct PCB* next;
}PCB;
struct PCB* makePCB(int pID, int pages_max){
PCB *newPCB = (PCB*)malloc(sizeof(PCB));
newPCB->PC_page=0;
newPCB->PC_offset=0;
newPCB->next=NULL;
newPCB->pID=pID;
newPCB->pages_max=pages_max;
for(int i=0; i<10; i++){
newPCB->pageTable[i]=-1;
}
return newPCB;
}
|
the_stack_data/107463.c | #include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
// https://www.geeksforgeeks.org/c-program-to-compare-two-strings-without-using-strcmp-function/
int compareStrings(char* x, char* y)
{
int flag = 0;
while (*x != '\0' || *y != '\0') {
if (*x == *y) {
x++;
y++;
}
else if ((*x == '\0' && *y != '\0')
|| (*x != '\0' && *y == '\0')
|| *x != *y) {
return 1;
}
}
return 0;
}
// https://gist.github.com/Ztuu/e9106e9095422a7d7266653f1e156366
char *rot13(const char *src)
{
if(src == NULL){
return NULL;
}
char* result = malloc(strlen(src));
if(result != NULL){
strcpy(result, src);
char* current_char = result;
while(*current_char != '\0'){
//Only increment alphabet characters
if((*current_char >= 97 && *current_char <= 122) || (*current_char >= 65 && *current_char <= 90)){
if(*current_char > 109 || (*current_char > 77 && *current_char < 91)){
//Characters that wrap around to the start of the alphabet
*current_char -= 13;
}else{
//Characters that can be safely incremented
*current_char += 13;
}
}
current_char++;
}
}
return result;
}
int main(int argc, char *argv[]){
if(argc==2){
printf("Checking Licence: %s\n", argv[1]);
if(compareStrings(argv[1], rot13("uryyb_fgenatre"))==0){
printf("Access Granted!\n");
setuid(0);
setgid(0);
system("/usr/bin/ps");
}
else{
printf("Wrong!\n");
}
}
else{
fprintf(stderr, "Usage: %s <name>\n", argv[0]);
return 1;
}
return 0;
} |
the_stack_data/608368.c | #include <stdio.h>
int main(void){
double x;
double y;
printf("input a number x :"); scanf("%lf", &x);
printf("input a number y :"); scanf("%lf", &y);
printf("x + y = %f \n", x + y );
printf("x - y = %f \n", x - y );
printf("x * y = %f \n", x * y );
printf("x / y = %f \n", x / y );
// printf("x %% y = %f \n", x % y );
return (0);
}
|
the_stack_data/28694.c | #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void find(char* str, char separator[100])
{
int i;
int size = strlen(str);
char buff[2];
for(i = 3; i<size -1; i++)
{
buff[0]=str[i];
buff[1]='\0';
strcat(separator, &buff);
}
}
void printNum(int start, int diff, int end, char* separator)
{
while(start<=end)
{
printf("%d",start);
start+=diff;
if(start<=end)
printf("%s",separator);
}
}
void printNumW(int start, int diff, int end, char* separator)
{
char buff[100];
sprintf(buff, "%d", end); // itoa(3) е нестандартна функция!
int n = strlen(buff);
while(start<=end)
{
printf("%0*d", n, start);
start+=diff;
if(start<=end)
printf("%s",separator);
}
}
int main(int argc, char* argv[])
{
int start,end,diff;
char separator[100];
strcpy(separator,"");
if(argc < 2)
{
perror(argv[0]);
return 1;
}
if(argc == 2)
{
start =1;
end = atoi(argv[1]);
diff=1;
strcpy(separator,"\n");
printNum(start,diff,end,separator);
}
else
{
if(argv[1][0]=='-' && argv[1][1]=='s')
{
find(argv[1], separator);
if(argv[2][0]=='-')
{
if(argc==4)
{
end = atoi(argv[3]);
start = 1;
diff = 1;
}
else if(argc==5)
{
start = atoi(argv[3]);
diff = 1;
end = atoi(argv[4]);
}
else if(argc==6)
{
start = atoi(argv[3]);
diff = atoi(argv[4]);
end = atoi(argv[5]);
}
printNumW(start,diff,end,separator);
}
else
{
if(argc==3)
{
end = atoi(argv[2]);
start = 1;
diff = 1;
}
else if(argc==4)
{
start = atoi(argv[2]);
diff = 1;
end = atoi(argv[3]);
}
else if(argc==5)
{
start = atoi(argv[2]);
diff = atoi(argv[3]);
end = atoi(argv[4]);
}
printNum(start,diff,end,separator);
}
}
else if(argv[1][0]=='-' && argv[1][1]=='w')
{
if(argv[2][0]=='-')
{
find(argv[2], separator);
if(argc==4)
{
end = atoi(argv[3]);
start = 1;
diff = 1;
}
else if(argc==5)
{
start = atoi(argv[3]);
diff = 1;
end = atoi(argv[4]);
}
else if(argc==6)
{
start = atoi(argv[3]);
diff = atoi(argv[4]);
end = atoi(argv[5]);
}
}
else
{
strcpy(separator,"\n");
if(argc==3)
{
end = atoi(argv[2]);
start = 1;
diff = 1;
}
else if(argc==4)
{
start = atoi(argv[2]);
diff = 1;
end = atoi(argv[3]);
}
else if(argc==5)
{
start = atoi(argv[2]);
diff = atoi(argv[3]);
end = atoi(argv[4]);
}
}
printNumW(start,diff,end,separator);
}
else
{
strcpy(separator,"\n");
if(argc==3)
{
start = atoi(argv[1]);
end = atoi(argv[2]);
diff=1;
}
else if(argc==4)
{
start = atoi(argv[1]);
diff = atoi(argv[2]);
end = atoi(argv[3]);
}
printNum(start,diff,end,separator);
}
}
return 0;
}
|
the_stack_data/120325.c | #include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
int system(char input[]){
int tam = strlen(input);
char* command[tam];
char* token;
int i;
int status;
char copy_input[tam]; // Necessário, senão não funcionaria com o strtok pois podia receber const char input[]
strcpy(copy_input, input);
token = strtok(copy_input, " ");
for (i = 0; token != NULL; i++) {
command[i] = token;
token = strtok(NULL, " ");
}
command[i] = NULL;
pid_t pid;
pid = fork();
if (pid < 0) {
perror("Fork failed.");
return -1;
} else if (pid == 0) {
execvp(command[0], command);
return -1;
} else {
wait(&status);
return WEXITSTATUS(status);
}
}
int main(int argc, const char *argv[]){
system("ls -l");
sleep(2);
system("pwd");
sleep(2);
system("ps -e");
return 0;
}
|
the_stack_data/66818.c | #include <stdio.h> /* for printf() and fprintf() */
#include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
#include <arpa/inet.h> /* for sockaddr_in and inet_addr() */
#include <stdlib.h> /* for atoi() and exit() */
#include <string.h> /* for memset() */
#include <unistd.h> /* for close() */
#define RCVBUFSIZE 32 /* Size of receive buffer */
void DieWithError(char *errorMessage); /* Error handling function */
int main(int argc, char *argv[])
{
int sock; /* Socket descriptor */
struct sockaddr_in echoServAddr; /* Echo server address */
unsigned short echoServPort; /* Echo server port */
char *servIP; /* Server IP address (dotted quad) */
char *echoString; /* String to send to echo server */
char echoBuffer[RCVBUFSIZE]; /* Buffer for echo string */
unsigned int echoStringLen; /* Length of string to echo */
int bytesRcvd, totalBytesRcvd; /* Bytes read in single recv()
and total bytes read */
if ((argc < 3) || (argc > 4)) /* Test for correct number of arguments */
{
fprintf(stderr, "Usage: %s <Server IP> <Echo Word> [<Echo Port>]\n",
argv[0]);
exit(1);
}
servIP = argv[1]; /* First arg: server IP address (dotted quad) */
echoString = argv[2]; /* Second arg: string to echo */
if (argc == 4)
echoServPort = atoi(argv[3]); /* Use given port, if any */
else
echoServPort = 7; /* 7 is the well-known port for the echo service */
/* Create a reliable, stream socket using TCP */
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
DieWithError("socket() failed");
/* Construct the server address structure */
memset(&echoServAddr, 0, sizeof(echoServAddr)); /* Zero out structure */
echoServAddr.sin_family = AF_INET; /* Internet address family */
echoServAddr.sin_addr.s_addr = inet_addr(servIP); /* Server IP address */
echoServAddr.sin_port = htons(echoServPort); /* Server port */
/* Establish the connection to the echo server */
if (connect(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
DieWithError("connect() failed");
echoStringLen = strlen(echoString); /* Determine input length */
/* Send the string to the server */
if (send(sock, echoString, echoStringLen, 0) != echoStringLen)
DieWithError("send() sent a different number of bytes than expected");
/* Receive the same string back from the server */
totalBytesRcvd = 0;
printf("Received: "); /* Setup to print the echoed string */
while (totalBytesRcvd < echoStringLen)
{
/* Receive up to the buffer size (minus 1 to leave space for
a null terminator) bytes from the sender */
if ((bytesRcvd = recv(sock, echoBuffer, RCVBUFSIZE - 1, 0)) <= 0)
DieWithError("recv() failed or connection closed prematurely");
totalBytesRcvd += bytesRcvd; /* Keep tally of total bytes */
echoBuffer[bytesRcvd] = '\0'; /* Terminate the string! */
printf("%s", echoBuffer); /* Print the echo buffer */
}
printf("\n"); /* Print a final linefeed */
close(sock);
exit(0);
}
void DieWithError(char *errorMessage)
{
perror(errorMessage);
exit(1);
}
void HandleTCPClient(int clntSocket)
{
char echoBuffer[RCVBUFSIZE]; /* Buffer for echo string */
int recvMsgSize; /* Size of received message */
/* Receive message from client */
if ((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0)
DieWithError("recv() failed");
/* Send received string and receive again until end of transmission */
while (recvMsgSize > 0) /* zero indicates end of transmission */
{
/* Echo message back to client */
if (send(clntSocket, echoBuffer, recvMsgSize, 0) != recvMsgSize)
DieWithError("send() failed");
/* See if there is more data to receive */
if ((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0)
DieWithError("recv() failed");
}
close(clntSocket); /* Close client socket */
}
|
the_stack_data/165764935.c |
#include <stdio.h>
#include <stdlib.h>
void cleanup() {
printf("cleanup ...\n");
}
int main(int argc, char* argv[]) {
printf("process running ...\n");
atexit(cleanup);
printf("buffer information ...");
_Exit(0);
return 0;
}
|
the_stack_data/168893918.c | #include <stdio.h>
int main(int argc, char *argv[])
{
char *pc;
printf(" sizeof(int)=%d sizeof(long)=%d sizeof(short)=%d sizeof(address)=%d sizeof(char)\n",
sizeof(int), sizeof(long), sizeof(short), sizeof(pc), sizeof(*pc));
printf(" sizeof(float)=%d sizeof(double)=%d sizeof(long double)=%d\n",
sizeof(float), sizeof(double), sizeof(long double));
return(0);
}
|
the_stack_data/242331071.c | /* show_salary.c -- 根据工时打印工资总额，税金和净工资 */
#include <stdio.h>
#define EXTRA_WORK_TIME_RATE 1.5
#define TAX_RATE_1 0.15
#define TAX_RATE_2 0.20
#define TAX_RATE_3 0.25
#define TAX_VALUE_1 300
#define TAX_VALUE_2 ((TAX_VALUE_1) + 150)
#define BASE_WORK_HOURS 40
int main(void)
{
float work_hours;
float pay_rate = 10.0;
float total_work_hours;
float salary, tax, net_salary;
printf("Enter your work_hour of the week:");
scanf("%f", &work_hours);
// 计算工时，包括加班
if (work_hours > BASE_WORK_HOURS)
total_work_hours = BASE_WORK_HOURS + (work_hours - BASE_WORK_HOURS) * EXTRA_WORK_TIME_RATE;
else
total_work_hours = work_hours;
// 计算工资
salary = total_work_hours * pay_rate;
// 计算税金
if (salary <= TAX_VALUE_1)
tax = salary * TAX_RATE_1;
else if (salary <= TAX_VALUE_2)
tax = TAX_VALUE_1 * TAX_RATE_1 + (salary - TAX_VALUE_1) * TAX_RATE_2;
else
tax = TAX_VALUE_1 * TAX_RATE_1 + (TAX_VALUE_2 - TAX_VALUE_1) * TAX_RATE_2 + (salary - TAX_VALUE_2) * TAX_RATE_3;
// 计算净工资
net_salary = salary - tax;
printf("salary is %.2f, tax is %.2f, net_salary is %.2f\n", salary, tax, net_salary);
printf("\n---------------------------------------------\n");
return 0;
} |
the_stack_data/11316.c | // RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVE -O0 -triple=i686-unknown-unknown -target-feature +xsave -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVE
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVE -O0 -triple=i686-unknown-unknown -target-feature +xsave -fno-signed-char -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVE
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XGETBV -O0 -triple=i686-unknown-unknown -target-feature +xsave -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XGETBV
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSETBV -O0 -triple=i686-unknown-unknown -target-feature +xsave -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSETBV
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVEOPT -O0 -triple=i686-unknown-unknown -target-feature +xsave -target-feature +xsaveopt -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVEOPT
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVEOPT -O0 -triple=i686-unknown-unknown -target-feature +xsave -target-feature +xsaveopt -fno-signed-char -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVEOPT
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVEC -O0 -triple=i686-unknown-unknown -target-feature +xsave -target-feature +xsavec -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVEC
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVEC -O0 -triple=i686-unknown-unknown -target-feature +xsave -target-feature +xsavec -fno-signed-char -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVEC
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVES -O0 -triple=i686-unknown-unknown -target-feature +xsave -target-feature +xsaves -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVES
// RUN: %clang_cc1 -no-opaque-pointers %s -DTEST_XSAVES -O0 -triple=i686-unknown-unknown -target-feature +xsave -target-feature +xsaves -fno-signed-char -emit-llvm -o - -Wall -Wno-unused-but-set-variable -Werror | FileCheck %s --check-prefix=XSAVES
// Don't include mm_malloc.h, it's system specific.
#define __MM_MALLOC_H
#include <x86intrin.h>
void test(void) {
unsigned long long tmp_ULLi;
unsigned int tmp_Ui;
void* tmp_vp;
tmp_ULLi = 0; tmp_Ui = 0; tmp_vp = 0;
#ifdef TEST_XSAVE
// XSAVE: [[tmp_vp_1:%[0-9a-zA-Z]+]] = load i8*, i8** %tmp_vp, align 4
// XSAVE: [[tmp_ULLi_1:%[0-9a-zA-Z]+]] = load i64, i64* %tmp_ULLi, align 8
// XSAVE: [[high64_1:%[0-9a-zA-Z]+]] = lshr i64 [[tmp_ULLi_1]], 32
// XSAVE: [[high32_1:%[0-9a-zA-Z]+]] = trunc i64 [[high64_1]] to i32
// XSAVE: [[low32_1:%[0-9a-zA-Z]+]] = trunc i64 [[tmp_ULLi_1]] to i32
// XSAVE: call void @llvm.x86.xsave(i8* [[tmp_vp_1]], i32 [[high32_1]], i32 [[low32_1]])
(void)__builtin_ia32_xsave(tmp_vp, tmp_ULLi);
// XSAVE: [[tmp_vp_3:%[0-9a-zA-Z]+]] = load i8*, i8** %tmp_vp, align 4
// XSAVE: [[tmp_ULLi_3:%[0-9a-zA-Z]+]] = load i64, i64* %tmp_ULLi, align 8
// XSAVE: [[high64_3:%[0-9a-zA-Z]+]] = lshr i64 [[tmp_ULLi_3]], 32
// XSAVE: [[high32_3:%[0-9a-zA-Z]+]] = trunc i64 [[high64_3]] to i32
// XSAVE: [[low32_3:%[0-9a-zA-Z]+]] = trunc i64 [[tmp_ULLi_3]] to i32
// XSAVE: call void @llvm.x86.xrstor(i8* [[tmp_vp_3]], i32 [[high32_3]], i32 [[low32_3]])
(void)__builtin_ia32_xrstor(tmp_vp, tmp_ULLi);
// XSAVE: call void @llvm.x86.xsave
(void)_xsave(tmp_vp, tmp_ULLi);
// XSAVE: call void @llvm.x86.xrstor
(void)_xrstor(tmp_vp, tmp_ULLi);
#endif
#ifdef TEST_XSAVEOPT
// XSAVEOPT: [[tmp_vp_1:%[0-9a-zA-Z]+]] = load i8*, i8** %tmp_vp, align 4
// XSAVEOPT: [[tmp_ULLi_1:%[0-9a-zA-Z]+]] = load i64, i64* %tmp_ULLi, align 8
// XSAVEOPT: [[high64_1:%[0-9a-zA-Z]+]] = lshr i64 [[tmp_ULLi_1]], 32
// XSAVEOPT: [[high32_1:%[0-9a-zA-Z]+]] = trunc i64 [[high64_1]] to i32
// XSAVEOPT: [[low32_1:%[0-9a-zA-Z]+]] = trunc i64 [[tmp_ULLi_1]] to i32
// XSAVEOPT: call void @llvm.x86.xsaveopt(i8* [[tmp_vp_1]], i32 [[high32_1]], i32 [[low32_1]])
(void)__builtin_ia32_xsaveopt(tmp_vp, tmp_ULLi);
// XSAVEOPT: call void @llvm.x86.xsaveopt
(void)_xsaveopt(tmp_vp, tmp_ULLi);
#endif
#ifdef TEST_XSAVEC
// XSAVEC: [[tmp_vp_1:%[0-9a-zA-Z]+]] = load i8*, i8** %tmp_vp, align 4
// XSAVEC: [[tmp_ULLi_1:%[0-9a-zA-Z]+]] = load i64, i64* %tmp_ULLi, align 8
// XSAVEC: [[high64_1:%[0-9a-zA-Z]+]] = lshr i64 [[tmp_ULLi_1]], 32
// XSAVEC: [[high32_1:%[0-9a-zA-Z]+]] = trunc i64 [[high64_1]] to i32
// XSAVEC: [[low32_1:%[0-9a-zA-Z]+]] = trunc i64 [[tmp_ULLi_1]] to i32
// XSAVEC: call void @llvm.x86.xsavec(i8* [[tmp_vp_1]], i32 [[high32_1]], i32 [[low32_1]])
(void)__builtin_ia32_xsavec(tmp_vp, tmp_ULLi);
// XSAVEC: call void @llvm.x86.xsavec
(void)_xsavec(tmp_vp, tmp_ULLi);
#endif
#ifdef TEST_XSAVES
// XSAVES: [[tmp_vp_1:%[0-9a-zA-Z]+]] = load i8*, i8** %tmp_vp, align 4
// XSAVES: [[tmp_ULLi_1:%[0-9a-zA-Z]+]] = load i64, i64* %tmp_ULLi, align 8
// XSAVES: [[high64_1:%[0-9a-zA-Z]+]] = lshr i64 [[tmp_ULLi_1]], 32
// XSAVES: [[high32_1:%[0-9a-zA-Z]+]] = trunc i64 [[high64_1]] to i32
// XSAVES: [[low32_1:%[0-9a-zA-Z]+]] = trunc i64 [[tmp_ULLi_1]] to i32
// XSAVES: call void @llvm.x86.xsaves(i8* [[tmp_vp_1]], i32 [[high32_1]], i32 [[low32_1]])
(void)__builtin_ia32_xsaves(tmp_vp, tmp_ULLi);
// XSAVES: [[tmp_vp_3:%[0-9a-zA-Z]+]] = load i8*, i8** %tmp_vp, align 4
// XSAVES: [[tmp_ULLi_3:%[0-9a-zA-Z]+]] = load i64, i64* %tmp_ULLi, align 8
// XSAVES: [[high64_3:%[0-9a-zA-Z]+]] = lshr i64 [[tmp_ULLi_3]], 32
// XSAVES: [[high32_3:%[0-9a-zA-Z]+]] = trunc i64 [[high64_3]] to i32
// XSAVES: [[low32_3:%[0-9a-zA-Z]+]] = trunc i64 [[tmp_ULLi_3]] to i32
// XSAVES: call void @llvm.x86.xrstors(i8* [[tmp_vp_3]], i32 [[high32_3]], i32 [[low32_3]])
(void)__builtin_ia32_xrstors(tmp_vp, tmp_ULLi);
// XSAVES: call void @llvm.x86.xsaves
(void)_xsaves(tmp_vp, tmp_ULLi);
// XSAVES: call void @llvm.x86.xrstors
(void)_xrstors(tmp_vp, tmp_ULLi);
#endif
#ifdef TEST_XGETBV
// XGETBV: [[tmp_Ui:%[0-9a-zA-z]+]] = load i32, i32* %tmp_Ui, align 4
// XGETBV: call i64 @llvm.x86.xgetbv(i32 [[tmp_Ui]])
tmp_ULLi = __builtin_ia32_xgetbv(tmp_Ui);
// XGETBV: call i64 @llvm.x86.xgetbv
tmp_ULLi = _xgetbv(tmp_Ui);
#endif
#ifdef TEST_XSETBV
// XSETBV: [[tmp_Ui:%[0-9a-zA-z]+]] = load i32, i32* %tmp_Ui, align 4
// XSETBV: [[tmp_ULLi_3:%[0-9a-zA-z]+]] = load i64, i64* %tmp_ULLi, align 8
// XSETBV: [[high64_3:%[0-9a-zA-z]+]] = lshr i64 [[tmp_ULLi_3]], 32
// XSETBV: [[high32_3:%[0-9a-zA-z]+]] = trunc i64 [[high64_3]] to i32
// XSETBV: [[low32_3:%[0-9a-zA-z]+]] = trunc i64 [[tmp_ULLi_3]] to i32
// XSETBV: call void @llvm.x86.xsetbv(i32 [[tmp_Ui]], i32 [[high32_3]], i32 [[low32_3]])
(void)__builtin_ia32_xsetbv(tmp_Ui, tmp_ULLi);
// XSETBV: call void @llvm.x86.xsetbv
(void)_xsetbv(tmp_Ui, tmp_ULLi);
#endif
}
|
the_stack_data/36450.c | #include <stdio.h>
void butler(void);
int fathm_ft(int);
int main() {
int num;
num = 1;
printf("I am a simplee\b ");
printf("computer.\n");
printf("My favorite number\t is %d because it is first.\n", num);
//fathm_ft
int feet,fathmos;
fathmos = 2;
feet = fathm_ft(fathmos);
printf("There are %d feet in %d fathmos!\n",feet,fathmos);
printf("Yes, I said %d feet!\n", 6 * fathmos);
//two_func
printf("I will summon the butler function.\n");
butler();
printf("Yes, Bring me some tea and writeable CD-ROMS.\n");
return 0;
}
void butler (void){
printf("You rang, sir?\n");
}
/**
* 把英寻转换为英尺
* @param fathoms 英寻
* @return 英尺
*/
int fathm_ft(int fathoms){
int feet;
feet = 6 * fathoms;
return feet;
} |
the_stack_data/154828980.c | #include <stdio.h>
int func(int *p){
func1(p);
return 0;
}
int func1(int *p){
func2(p);
return 0;
}
int func2(int *p){
func3(p);
return 0;
}
int func3(int *p){
func4(p);
return 0;
}
int func4(int *p){
printf("p=%d\n",*p);
return 0;
}
int main(){
int *p;
int a=10;
int b=20;
int c=30;
printf("Assigned values\n");
func(p=5);
return 0;
}
|
the_stack_data/140765652.c | /* Copyright (C) 2008-2021 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/>. */
#ifdef __GNUC__
# define ATTR __attribute__((always_inline))
#else
# define ATTR
#endif
extern int x, y;
extern volatile int z;
void bar(void)
{
x += y; /* set breakpoint 1 here */
}
void marker(void)
{
x += y - z; /* set breakpoint 2 here */
}
inline ATTR void inlined_fn(void)
{
x += y + z;
}
void noinline(void)
{
inlined_fn (); /* inlined */
}
|
the_stack_data/97012495.c | /* ======================================================================== */
/* ========================= OPCODE TABLE BUILDER ========================= */
/* ======================================================================== */
/* This is modified to do the building of the tables on the host, so the device
that ends up running this can just fetch the table data from flash instead of
having to dedicate an expensive RAM array to it. */
#include <stdio.h>
#define NUM_CPU_TYPES 3
/* This is used to generate the opcode handler jump table */
typedef struct
{
// void (*opcode_handler)(void); /* handler function */
char *opcode_handler;
unsigned int mask; /* mask on opcode */
unsigned int match; /* what to match after masking */
unsigned char cycles[NUM_CPU_TYPES]; /* cycles each cpu type takes */
} opcode_handler_struct;
/* Opcode handler table */
static opcode_handler_struct m68k_opcode_handler_table[] =
{
/* function mask match 000 010 020 */
{"m68k_op_1010 ", 0xf000, 0xa000, { 4, 4, 4}},
{"m68k_op_1111 ", 0xf000, 0xf000, { 4, 4, 4}},
{"m68k_op_moveq_32 ", 0xf100, 0x7000, { 4, 4, 2}},
{"m68k_op_cpbcc_32 ", 0xf180, 0xf080, { 0, 0, 4}},
{"m68k_op_cpgen_32 ", 0xf1c0, 0xf000, { 0, 0, 4}},
{"m68k_op_cpscc_32 ", 0xf1c0, 0xf040, { 0, 0, 4}},
{"m68k_op_bra_8 ", 0xff00, 0x6000, { 10, 10, 10}},
{"m68k_op_bsr_8 ", 0xff00, 0x6100, { 18, 18, 7}},
{"m68k_op_bhi_8 ", 0xff00, 0x6200, { 10, 10, 6}},
{"m68k_op_bls_8 ", 0xff00, 0x6300, { 10, 10, 6}},
{"m68k_op_bcc_8 ", 0xff00, 0x6400, { 10, 10, 6}},
{"m68k_op_bcs_8 ", 0xff00, 0x6500, { 10, 10, 6}},
{"m68k_op_bne_8 ", 0xff00, 0x6600, { 10, 10, 6}},
{"m68k_op_beq_8 ", 0xff00, 0x6700, { 10, 10, 6}},
{"m68k_op_bvc_8 ", 0xff00, 0x6800, { 10, 10, 6}},
{"m68k_op_bvs_8 ", 0xff00, 0x6900, { 10, 10, 6}},
{"m68k_op_bpl_8 ", 0xff00, 0x6a00, { 10, 10, 6}},
{"m68k_op_bmi_8 ", 0xff00, 0x6b00, { 10, 10, 6}},
{"m68k_op_bge_8 ", 0xff00, 0x6c00, { 10, 10, 6}},
{"m68k_op_blt_8 ", 0xff00, 0x6d00, { 10, 10, 6}},
{"m68k_op_bgt_8 ", 0xff00, 0x6e00, { 10, 10, 6}},
{"m68k_op_ble_8 ", 0xff00, 0x6f00, { 10, 10, 6}},
{"m68k_op_btst_32_r_d ", 0xf1f8, 0x0100, { 6, 6, 4}},
{"m68k_op_movep_16_er ", 0xf1f8, 0x0108, { 16, 16, 12}},
{"m68k_op_btst_8_r_ai ", 0xf1f8, 0x0110, { 8, 8, 8}},
{"m68k_op_btst_8_r_pi ", 0xf1f8, 0x0118, { 8, 8, 8}},
{"m68k_op_btst_8_r_pd ", 0xf1f8, 0x0120, { 10, 10, 9}},
{"m68k_op_btst_8_r_di ", 0xf1f8, 0x0128, { 12, 12, 9}},
{"m68k_op_btst_8_r_ix ", 0xf1f8, 0x0130, { 14, 14, 11}},
{"m68k_op_bchg_32_r_d ", 0xf1f8, 0x0140, { 8, 8, 4}},
{"m68k_op_movep_32_er ", 0xf1f8, 0x0148, { 24, 24, 18}},
{"m68k_op_bchg_8_r_ai ", 0xf1f8, 0x0150, { 12, 12, 8}},
{"m68k_op_bchg_8_r_pi ", 0xf1f8, 0x0158, { 12, 12, 8}},
{"m68k_op_bchg_8_r_pd ", 0xf1f8, 0x0160, { 14, 14, 9}},
{"m68k_op_bchg_8_r_di ", 0xf1f8, 0x0168, { 16, 16, 9}},
{"m68k_op_bchg_8_r_ix ", 0xf1f8, 0x0170, { 18, 18, 11}},
{"m68k_op_bclr_32_r_d ", 0xf1f8, 0x0180, { 10, 10, 4}},
{"m68k_op_movep_16_re ", 0xf1f8, 0x0188, { 16, 16, 11}},
{"m68k_op_bclr_8_r_ai ", 0xf1f8, 0x0190, { 12, 14, 8}},
{"m68k_op_bclr_8_r_pi ", 0xf1f8, 0x0198, { 12, 14, 8}},
{"m68k_op_bclr_8_r_pd ", 0xf1f8, 0x01a0, { 14, 16, 9}},
{"m68k_op_bclr_8_r_di ", 0xf1f8, 0x01a8, { 16, 18, 9}},
{"m68k_op_bclr_8_r_ix ", 0xf1f8, 0x01b0, { 18, 20, 11}},
{"m68k_op_bset_32_r_d ", 0xf1f8, 0x01c0, { 8, 8, 4}},
{"m68k_op_movep_32_re ", 0xf1f8, 0x01c8, { 24, 24, 17}},
{"m68k_op_bset_8_r_ai ", 0xf1f8, 0x01d0, { 12, 12, 8}},
{"m68k_op_bset_8_r_pi ", 0xf1f8, 0x01d8, { 12, 12, 8}},
{"m68k_op_bset_8_r_pd ", 0xf1f8, 0x01e0, { 14, 14, 9}},
{"m68k_op_bset_8_r_di ", 0xf1f8, 0x01e8, { 16, 16, 9}},
{"m68k_op_bset_8_r_ix ", 0xf1f8, 0x01f0, { 18, 18, 11}},
{"m68k_op_move_8_d_d ", 0xf1f8, 0x1000, { 4, 4, 2}},
{"m68k_op_move_8_d_ai ", 0xf1f8, 0x1010, { 8, 8, 6}},
{"m68k_op_move_8_d_pi ", 0xf1f8, 0x1018, { 8, 8, 6}},
{"m68k_op_move_8_d_pd ", 0xf1f8, 0x1020, { 10, 10, 7}},
{"m68k_op_move_8_d_di ", 0xf1f8, 0x1028, { 12, 12, 7}},
{"m68k_op_move_8_d_ix ", 0xf1f8, 0x1030, { 14, 14, 9}},
{"m68k_op_move_8_ai_d ", 0xf1f8, 0x1080, { 8, 8, 4}},
{"m68k_op_move_8_ai_ai ", 0xf1f8, 0x1090, { 12, 12, 8}},
{"m68k_op_move_8_ai_pi ", 0xf1f8, 0x1098, { 12, 12, 8}},
{"m68k_op_move_8_ai_pd ", 0xf1f8, 0x10a0, { 14, 14, 9}},
{"m68k_op_move_8_ai_di ", 0xf1f8, 0x10a8, { 16, 16, 9}},
{"m68k_op_move_8_ai_ix ", 0xf1f8, 0x10b0, { 18, 18, 11}},
{"m68k_op_move_8_pi_d ", 0xf1f8, 0x10c0, { 8, 8, 4}},
{"m68k_op_move_8_pi_ai ", 0xf1f8, 0x10d0, { 12, 12, 8}},
{"m68k_op_move_8_pi_pi ", 0xf1f8, 0x10d8, { 12, 12, 8}},
{"m68k_op_move_8_pi_pd ", 0xf1f8, 0x10e0, { 14, 14, 9}},
{"m68k_op_move_8_pi_di ", 0xf1f8, 0x10e8, { 16, 16, 9}},
{"m68k_op_move_8_pi_ix ", 0xf1f8, 0x10f0, { 18, 18, 11}},
{"m68k_op_move_8_pd_d ", 0xf1f8, 0x1100, { 8, 8, 5}},
{"m68k_op_move_8_pd_ai ", 0xf1f8, 0x1110, { 12, 12, 9}},
{"m68k_op_move_8_pd_pi ", 0xf1f8, 0x1118, { 12, 12, 9}},
{"m68k_op_move_8_pd_pd ", 0xf1f8, 0x1120, { 14, 14, 10}},
{"m68k_op_move_8_pd_di ", 0xf1f8, 0x1128, { 16, 16, 10}},
{"m68k_op_move_8_pd_ix ", 0xf1f8, 0x1130, { 18, 18, 12}},
{"m68k_op_move_8_di_d ", 0xf1f8, 0x1140, { 12, 12, 5}},
{"m68k_op_move_8_di_ai ", 0xf1f8, 0x1150, { 16, 16, 9}},
{"m68k_op_move_8_di_pi ", 0xf1f8, 0x1158, { 16, 16, 9}},
{"m68k_op_move_8_di_pd ", 0xf1f8, 0x1160, { 18, 18, 10}},
{"m68k_op_move_8_di_di ", 0xf1f8, 0x1168, { 20, 20, 10}},
{"m68k_op_move_8_di_ix ", 0xf1f8, 0x1170, { 22, 22, 12}},
{"m68k_op_move_8_ix_d ", 0xf1f8, 0x1180, { 14, 14, 7}},
{"m68k_op_move_8_ix_ai ", 0xf1f8, 0x1190, { 18, 18, 11}},
{"m68k_op_move_8_ix_pi ", 0xf1f8, 0x1198, { 18, 18, 11}},
{"m68k_op_move_8_ix_pd ", 0xf1f8, 0x11a0, { 20, 20, 12}},
{"m68k_op_move_8_ix_di ", 0xf1f8, 0x11a8, { 22, 22, 12}},
{"m68k_op_move_8_ix_ix ", 0xf1f8, 0x11b0, { 24, 24, 14}},
{"m68k_op_move_32_d_d ", 0xf1f8, 0x2000, { 4, 4, 2}},
{"m68k_op_move_32_d_a ", 0xf1f8, 0x2008, { 4, 4, 2}},
{"m68k_op_move_32_d_ai ", 0xf1f8, 0x2010, { 12, 12, 6}},
{"m68k_op_move_32_d_pi ", 0xf1f8, 0x2018, { 12, 12, 6}},
{"m68k_op_move_32_d_pd ", 0xf1f8, 0x2020, { 14, 14, 7}},
{"m68k_op_move_32_d_di ", 0xf1f8, 0x2028, { 16, 16, 7}},
{"m68k_op_move_32_d_ix ", 0xf1f8, 0x2030, { 18, 18, 9}},
{"m68k_op_movea_32_d ", 0xf1f8, 0x2040, { 4, 4, 2}},
{"m68k_op_movea_32_a ", 0xf1f8, 0x2048, { 4, 4, 2}},
{"m68k_op_movea_32_ai ", 0xf1f8, 0x2050, { 12, 12, 6}},
{"m68k_op_movea_32_pi ", 0xf1f8, 0x2058, { 12, 12, 6}},
{"m68k_op_movea_32_pd ", 0xf1f8, 0x2060, { 14, 14, 7}},
{"m68k_op_movea_32_di ", 0xf1f8, 0x2068, { 16, 16, 7}},
{"m68k_op_movea_32_ix ", 0xf1f8, 0x2070, { 18, 18, 9}},
{"m68k_op_move_32_ai_d ", 0xf1f8, 0x2080, { 12, 12, 4}},
{"m68k_op_move_32_ai_a ", 0xf1f8, 0x2088, { 12, 12, 4}},
{"m68k_op_move_32_ai_ai ", 0xf1f8, 0x2090, { 20, 20, 8}},
{"m68k_op_move_32_ai_pi ", 0xf1f8, 0x2098, { 20, 20, 8}},
{"m68k_op_move_32_ai_pd ", 0xf1f8, 0x20a0, { 22, 22, 9}},
{"m68k_op_move_32_ai_di ", 0xf1f8, 0x20a8, { 24, 24, 9}},
{"m68k_op_move_32_ai_ix ", 0xf1f8, 0x20b0, { 26, 26, 11}},
{"m68k_op_move_32_pi_d ", 0xf1f8, 0x20c0, { 12, 12, 4}},
{"m68k_op_move_32_pi_a ", 0xf1f8, 0x20c8, { 12, 12, 4}},
{"m68k_op_move_32_pi_ai ", 0xf1f8, 0x20d0, { 20, 20, 8}},
{"m68k_op_move_32_pi_pi ", 0xf1f8, 0x20d8, { 20, 20, 8}},
{"m68k_op_move_32_pi_pd ", 0xf1f8, 0x20e0, { 22, 22, 9}},
{"m68k_op_move_32_pi_di ", 0xf1f8, 0x20e8, { 24, 24, 9}},
{"m68k_op_move_32_pi_ix ", 0xf1f8, 0x20f0, { 26, 26, 11}},
{"m68k_op_move_32_pd_d ", 0xf1f8, 0x2100, { 12, 14, 5}},
{"m68k_op_move_32_pd_a ", 0xf1f8, 0x2108, { 12, 14, 5}},
{"m68k_op_move_32_pd_ai ", 0xf1f8, 0x2110, { 20, 22, 9}},
{"m68k_op_move_32_pd_pi ", 0xf1f8, 0x2118, { 20, 22, 9}},
{"m68k_op_move_32_pd_pd ", 0xf1f8, 0x2120, { 22, 24, 10}},
{"m68k_op_move_32_pd_di ", 0xf1f8, 0x2128, { 24, 26, 10}},
{"m68k_op_move_32_pd_ix ", 0xf1f8, 0x2130, { 26, 28, 12}},
{"m68k_op_move_32_di_d ", 0xf1f8, 0x2140, { 16, 16, 5}},
{"m68k_op_move_32_di_a ", 0xf1f8, 0x2148, { 16, 16, 5}},
{"m68k_op_move_32_di_ai ", 0xf1f8, 0x2150, { 24, 24, 9}},
{"m68k_op_move_32_di_pi ", 0xf1f8, 0x2158, { 24, 24, 9}},
{"m68k_op_move_32_di_pd ", 0xf1f8, 0x2160, { 26, 26, 10}},
{"m68k_op_move_32_di_di ", 0xf1f8, 0x2168, { 28, 28, 10}},
{"m68k_op_move_32_di_ix ", 0xf1f8, 0x2170, { 30, 30, 12}},
{"m68k_op_move_32_ix_d ", 0xf1f8, 0x2180, { 18, 18, 7}},
{"m68k_op_move_32_ix_a ", 0xf1f8, 0x2188, { 18, 18, 7}},
{"m68k_op_move_32_ix_ai ", 0xf1f8, 0x2190, { 26, 26, 11}},
{"m68k_op_move_32_ix_pi ", 0xf1f8, 0x2198, { 26, 26, 11}},
{"m68k_op_move_32_ix_pd ", 0xf1f8, 0x21a0, { 28, 28, 12}},
{"m68k_op_move_32_ix_di ", 0xf1f8, 0x21a8, { 30, 30, 12}},
{"m68k_op_move_32_ix_ix ", 0xf1f8, 0x21b0, { 32, 32, 14}},
{"m68k_op_move_16_d_d ", 0xf1f8, 0x3000, { 4, 4, 2}},
{"m68k_op_move_16_d_a ", 0xf1f8, 0x3008, { 4, 4, 2}},
{"m68k_op_move_16_d_ai ", 0xf1f8, 0x3010, { 8, 8, 6}},
{"m68k_op_move_16_d_pi ", 0xf1f8, 0x3018, { 8, 8, 6}},
{"m68k_op_move_16_d_pd ", 0xf1f8, 0x3020, { 10, 10, 7}},
{"m68k_op_move_16_d_di ", 0xf1f8, 0x3028, { 12, 12, 7}},
{"m68k_op_move_16_d_ix ", 0xf1f8, 0x3030, { 14, 14, 9}},
{"m68k_op_movea_16_d ", 0xf1f8, 0x3040, { 4, 4, 2}},
{"m68k_op_movea_16_a ", 0xf1f8, 0x3048, { 4, 4, 2}},
{"m68k_op_movea_16_ai ", 0xf1f8, 0x3050, { 8, 8, 6}},
{"m68k_op_movea_16_pi ", 0xf1f8, 0x3058, { 8, 8, 6}},
{"m68k_op_movea_16_pd ", 0xf1f8, 0x3060, { 10, 10, 7}},
{"m68k_op_movea_16_di ", 0xf1f8, 0x3068, { 12, 12, 7}},
{"m68k_op_movea_16_ix ", 0xf1f8, 0x3070, { 14, 14, 9}},
{"m68k_op_move_16_ai_d ", 0xf1f8, 0x3080, { 8, 8, 4}},
{"m68k_op_move_16_ai_a ", 0xf1f8, 0x3088, { 8, 8, 4}},
{"m68k_op_move_16_ai_ai ", 0xf1f8, 0x3090, { 12, 12, 8}},
{"m68k_op_move_16_ai_pi ", 0xf1f8, 0x3098, { 12, 12, 8}},
{"m68k_op_move_16_ai_pd ", 0xf1f8, 0x30a0, { 14, 14, 9}},
{"m68k_op_move_16_ai_di ", 0xf1f8, 0x30a8, { 16, 16, 9}},
{"m68k_op_move_16_ai_ix ", 0xf1f8, 0x30b0, { 18, 18, 11}},
{"m68k_op_move_16_pi_d ", 0xf1f8, 0x30c0, { 8, 8, 4}},
{"m68k_op_move_16_pi_a ", 0xf1f8, 0x30c8, { 8, 8, 4}},
{"m68k_op_move_16_pi_ai ", 0xf1f8, 0x30d0, { 12, 12, 8}},
{"m68k_op_move_16_pi_pi ", 0xf1f8, 0x30d8, { 12, 12, 8}},
{"m68k_op_move_16_pi_pd ", 0xf1f8, 0x30e0, { 14, 14, 9}},
{"m68k_op_move_16_pi_di ", 0xf1f8, 0x30e8, { 16, 16, 9}},
{"m68k_op_move_16_pi_ix ", 0xf1f8, 0x30f0, { 18, 18, 11}},
{"m68k_op_move_16_pd_d ", 0xf1f8, 0x3100, { 8, 8, 5}},
{"m68k_op_move_16_pd_a ", 0xf1f8, 0x3108, { 8, 8, 5}},
{"m68k_op_move_16_pd_ai ", 0xf1f8, 0x3110, { 12, 12, 9}},
{"m68k_op_move_16_pd_pi ", 0xf1f8, 0x3118, { 12, 12, 9}},
{"m68k_op_move_16_pd_pd ", 0xf1f8, 0x3120, { 14, 14, 10}},
{"m68k_op_move_16_pd_di ", 0xf1f8, 0x3128, { 16, 16, 10}},
{"m68k_op_move_16_pd_ix ", 0xf1f8, 0x3130, { 18, 18, 12}},
{"m68k_op_move_16_di_d ", 0xf1f8, 0x3140, { 12, 12, 5}},
{"m68k_op_move_16_di_a ", 0xf1f8, 0x3148, { 12, 12, 5}},
{"m68k_op_move_16_di_ai ", 0xf1f8, 0x3150, { 16, 16, 9}},
{"m68k_op_move_16_di_pi ", 0xf1f8, 0x3158, { 16, 16, 9}},
{"m68k_op_move_16_di_pd ", 0xf1f8, 0x3160, { 18, 18, 10}},
{"m68k_op_move_16_di_di ", 0xf1f8, 0x3168, { 20, 20, 10}},
{"m68k_op_move_16_di_ix ", 0xf1f8, 0x3170, { 22, 22, 12}},
{"m68k_op_move_16_ix_d ", 0xf1f8, 0x3180, { 14, 14, 7}},
{"m68k_op_move_16_ix_a ", 0xf1f8, 0x3188, { 14, 14, 7}},
{"m68k_op_move_16_ix_ai ", 0xf1f8, 0x3190, { 18, 18, 11}},
{"m68k_op_move_16_ix_pi ", 0xf1f8, 0x3198, { 18, 18, 11}},
{"m68k_op_move_16_ix_pd ", 0xf1f8, 0x31a0, { 20, 20, 12}},
{"m68k_op_move_16_ix_di ", 0xf1f8, 0x31a8, { 22, 22, 12}},
{"m68k_op_move_16_ix_ix ", 0xf1f8, 0x31b0, { 24, 24, 14}},
{"m68k_op_chk_32_d ", 0xf1f8, 0x4100, { 0, 0, 8}},
{"m68k_op_chk_32_ai ", 0xf1f8, 0x4110, { 0, 0, 12}},
{"m68k_op_chk_32_pi ", 0xf1f8, 0x4118, { 0, 0, 12}},
{"m68k_op_chk_32_pd ", 0xf1f8, 0x4120, { 0, 0, 13}},
{"m68k_op_chk_32_di ", 0xf1f8, 0x4128, { 0, 0, 13}},
{"m68k_op_chk_32_ix ", 0xf1f8, 0x4130, { 0, 0, 15}},
{"m68k_op_chk_16_d ", 0xf1f8, 0x4180, { 10, 8, 8}},
{"m68k_op_chk_16_ai ", 0xf1f8, 0x4190, { 14, 12, 12}},
{"m68k_op_chk_16_pi ", 0xf1f8, 0x4198, { 14, 12, 12}},
{"m68k_op_chk_16_pd ", 0xf1f8, 0x41a0, { 16, 14, 13}},
{"m68k_op_chk_16_di ", 0xf1f8, 0x41a8, { 18, 16, 13}},
{"m68k_op_chk_16_ix ", 0xf1f8, 0x41b0, { 20, 18, 15}},
{"m68k_op_lea_32_ai ", 0xf1f8, 0x41d0, { 4, 4, 6}},
{"m68k_op_lea_32_di ", 0xf1f8, 0x41e8, { 8, 8, 7}},
{"m68k_op_lea_32_ix ", 0xf1f8, 0x41f0, { 12, 12, 9}},
{"m68k_op_addq_8_d ", 0xf1f8, 0x5000, { 4, 4, 2}},
{"m68k_op_addq_8_ai ", 0xf1f8, 0x5010, { 12, 12, 8}},
{"m68k_op_addq_8_pi ", 0xf1f8, 0x5018, { 12, 12, 8}},
{"m68k_op_addq_8_pd ", 0xf1f8, 0x5020, { 14, 14, 9}},
{"m68k_op_addq_8_di ", 0xf1f8, 0x5028, { 16, 16, 9}},
{"m68k_op_addq_8_ix ", 0xf1f8, 0x5030, { 18, 18, 11}},
{"m68k_op_addq_16_d ", 0xf1f8, 0x5040, { 4, 4, 2}},
{"m68k_op_addq_16_a ", 0xf1f8, 0x5048, { 4, 4, 2}},
{"m68k_op_addq_16_ai ", 0xf1f8, 0x5050, { 12, 12, 8}},
{"m68k_op_addq_16_pi ", 0xf1f8, 0x5058, { 12, 12, 8}},
{"m68k_op_addq_16_pd ", 0xf1f8, 0x5060, { 14, 14, 9}},
{"m68k_op_addq_16_di ", 0xf1f8, 0x5068, { 16, 16, 9}},
{"m68k_op_addq_16_ix ", 0xf1f8, 0x5070, { 18, 18, 11}},
{"m68k_op_addq_32_d ", 0xf1f8, 0x5080, { 8, 8, 2}},
{"m68k_op_addq_32_a ", 0xf1f8, 0x5088, { 8, 8, 2}},
{"m68k_op_addq_32_ai ", 0xf1f8, 0x5090, { 20, 20, 8}},
{"m68k_op_addq_32_pi ", 0xf1f8, 0x5098, { 20, 20, 8}},
{"m68k_op_addq_32_pd ", 0xf1f8, 0x50a0, { 22, 22, 9}},
{"m68k_op_addq_32_di ", 0xf1f8, 0x50a8, { 24, 24, 9}},
{"m68k_op_addq_32_ix ", 0xf1f8, 0x50b0, { 26, 26, 11}},
{"m68k_op_subq_8_d ", 0xf1f8, 0x5100, { 4, 4, 2}},
{"m68k_op_subq_8_ai ", 0xf1f8, 0x5110, { 12, 12, 8}},
{"m68k_op_subq_8_pi ", 0xf1f8, 0x5118, { 12, 12, 8}},
{"m68k_op_subq_8_pd ", 0xf1f8, 0x5120, { 14, 14, 9}},
{"m68k_op_subq_8_di ", 0xf1f8, 0x5128, { 16, 16, 9}},
{"m68k_op_subq_8_ix ", 0xf1f8, 0x5130, { 18, 18, 11}},
{"m68k_op_subq_16_d ", 0xf1f8, 0x5140, { 4, 4, 2}},
{"m68k_op_subq_16_a ", 0xf1f8, 0x5148, { 8, 4, 2}},
{"m68k_op_subq_16_ai ", 0xf1f8, 0x5150, { 12, 12, 8}},
{"m68k_op_subq_16_pi ", 0xf1f8, 0x5158, { 12, 12, 8}},
{"m68k_op_subq_16_pd ", 0xf1f8, 0x5160, { 14, 14, 9}},
{"m68k_op_subq_16_di ", 0xf1f8, 0x5168, { 16, 16, 9}},
{"m68k_op_subq_16_ix ", 0xf1f8, 0x5170, { 18, 18, 11}},
{"m68k_op_subq_32_d ", 0xf1f8, 0x5180, { 8, 8, 2}},
{"m68k_op_subq_32_a ", 0xf1f8, 0x5188, { 8, 8, 2}},
{"m68k_op_subq_32_ai ", 0xf1f8, 0x5190, { 20, 20, 8}},
{"m68k_op_subq_32_pi ", 0xf1f8, 0x5198, { 20, 20, 8}},
{"m68k_op_subq_32_pd ", 0xf1f8, 0x51a0, { 22, 22, 9}},
{"m68k_op_subq_32_di ", 0xf1f8, 0x51a8, { 24, 24, 9}},
{"m68k_op_subq_32_ix ", 0xf1f8, 0x51b0, { 26, 26, 11}},
{"m68k_op_or_8_er_d ", 0xf1f8, 0x8000, { 4, 4, 2}},
{"m68k_op_or_8_er_ai ", 0xf1f8, 0x8010, { 8, 8, 6}},
{"m68k_op_or_8_er_pi ", 0xf1f8, 0x8018, { 8, 8, 6}},
{"m68k_op_or_8_er_pd ", 0xf1f8, 0x8020, { 10, 10, 7}},
{"m68k_op_or_8_er_di ", 0xf1f8, 0x8028, { 12, 12, 7}},
{"m68k_op_or_8_er_ix ", 0xf1f8, 0x8030, { 14, 14, 9}},
{"m68k_op_or_16_er_d ", 0xf1f8, 0x8040, { 4, 4, 2}},
{"m68k_op_or_16_er_ai ", 0xf1f8, 0x8050, { 8, 8, 6}},
{"m68k_op_or_16_er_pi ", 0xf1f8, 0x8058, { 8, 8, 6}},
{"m68k_op_or_16_er_pd ", 0xf1f8, 0x8060, { 10, 10, 7}},
{"m68k_op_or_16_er_di ", 0xf1f8, 0x8068, { 12, 12, 7}},
{"m68k_op_or_16_er_ix ", 0xf1f8, 0x8070, { 14, 14, 9}},
{"m68k_op_or_32_er_d ", 0xf1f8, 0x8080, { 6, 6, 2}},
{"m68k_op_or_32_er_ai ", 0xf1f8, 0x8090, { 14, 14, 6}},
{"m68k_op_or_32_er_pi ", 0xf1f8, 0x8098, { 14, 14, 6}},
{"m68k_op_or_32_er_pd ", 0xf1f8, 0x80a0, { 16, 16, 7}},
{"m68k_op_or_32_er_di ", 0xf1f8, 0x80a8, { 18, 18, 7}},
{"m68k_op_or_32_er_ix ", 0xf1f8, 0x80b0, { 20, 20, 9}},
{"m68k_op_divu_16_d ", 0xf1f8, 0x80c0, {140, 108, 44}},
{"m68k_op_divu_16_ai ", 0xf1f8, 0x80d0, {144, 112, 48}},
{"m68k_op_divu_16_pi ", 0xf1f8, 0x80d8, {144, 112, 48}},
{"m68k_op_divu_16_pd ", 0xf1f8, 0x80e0, {146, 114, 49}},
{"m68k_op_divu_16_di ", 0xf1f8, 0x80e8, {148, 116, 49}},
{"m68k_op_divu_16_ix ", 0xf1f8, 0x80f0, {150, 118, 51}},
{"m68k_op_sbcd_8_rr ", 0xf1f8, 0x8100, { 6, 6, 4}},
{"m68k_op_sbcd_8_mm ", 0xf1f8, 0x8108, { 18, 18, 16}},
{"m68k_op_or_8_re_ai ", 0xf1f8, 0x8110, { 12, 12, 8}},
{"m68k_op_or_8_re_pi ", 0xf1f8, 0x8118, { 12, 12, 8}},
{"m68k_op_or_8_re_pd ", 0xf1f8, 0x8120, { 14, 14, 9}},
{"m68k_op_or_8_re_di ", 0xf1f8, 0x8128, { 16, 16, 9}},
{"m68k_op_or_8_re_ix ", 0xf1f8, 0x8130, { 18, 18, 11}},
{"m68k_op_pack_16_rr ", 0xf1f8, 0x8140, { 0, 0, 6}},
{"m68k_op_pack_16_mm ", 0xf1f8, 0x8148, { 0, 0, 13}},
{"m68k_op_or_16_re_ai ", 0xf1f8, 0x8150, { 12, 12, 8}},
{"m68k_op_or_16_re_pi ", 0xf1f8, 0x8158, { 12, 12, 8}},
{"m68k_op_or_16_re_pd ", 0xf1f8, 0x8160, { 14, 14, 9}},
{"m68k_op_or_16_re_di ", 0xf1f8, 0x8168, { 16, 16, 9}},
{"m68k_op_or_16_re_ix ", 0xf1f8, 0x8170, { 18, 18, 11}},
{"m68k_op_unpk_16_rr ", 0xf1f8, 0x8180, { 0, 0, 8}},
{"m68k_op_unpk_16_mm ", 0xf1f8, 0x8188, { 0, 0, 13}},
{"m68k_op_or_32_re_ai ", 0xf1f8, 0x8190, { 20, 20, 8}},
{"m68k_op_or_32_re_pi ", 0xf1f8, 0x8198, { 20, 20, 8}},
{"m68k_op_or_32_re_pd ", 0xf1f8, 0x81a0, { 22, 22, 9}},
{"m68k_op_or_32_re_di ", 0xf1f8, 0x81a8, { 24, 24, 9}},
{"m68k_op_or_32_re_ix ", 0xf1f8, 0x81b0, { 26, 26, 11}},
{"m68k_op_divs_16_d ", 0xf1f8, 0x81c0, {158, 122, 56}},
{"m68k_op_divs_16_ai ", 0xf1f8, 0x81d0, {162, 126, 60}},
{"m68k_op_divs_16_pi ", 0xf1f8, 0x81d8, {162, 126, 60}},
{"m68k_op_divs_16_pd ", 0xf1f8, 0x81e0, {164, 128, 61}},
{"m68k_op_divs_16_di ", 0xf1f8, 0x81e8, {166, 130, 61}},
{"m68k_op_divs_16_ix ", 0xf1f8, 0x81f0, {168, 132, 63}},
{"m68k_op_sub_8_er_d ", 0xf1f8, 0x9000, { 4, 4, 2}},
{"m68k_op_sub_8_er_ai ", 0xf1f8, 0x9010, { 8, 8, 6}},
{"m68k_op_sub_8_er_pi ", 0xf1f8, 0x9018, { 8, 8, 6}},
{"m68k_op_sub_8_er_pd ", 0xf1f8, 0x9020, { 10, 10, 7}},
{"m68k_op_sub_8_er_di ", 0xf1f8, 0x9028, { 12, 12, 7}},
{"m68k_op_sub_8_er_ix ", 0xf1f8, 0x9030, { 14, 14, 9}},
{"m68k_op_sub_16_er_d ", 0xf1f8, 0x9040, { 4, 4, 2}},
{"m68k_op_sub_16_er_a ", 0xf1f8, 0x9048, { 4, 4, 2}},
{"m68k_op_sub_16_er_ai ", 0xf1f8, 0x9050, { 8, 8, 6}},
{"m68k_op_sub_16_er_pi ", 0xf1f8, 0x9058, { 8, 8, 6}},
{"m68k_op_sub_16_er_pd ", 0xf1f8, 0x9060, { 10, 10, 7}},
{"m68k_op_sub_16_er_di ", 0xf1f8, 0x9068, { 12, 12, 7}},
{"m68k_op_sub_16_er_ix ", 0xf1f8, 0x9070, { 14, 14, 9}},
{"m68k_op_sub_32_er_d ", 0xf1f8, 0x9080, { 6, 6, 2}},
{"m68k_op_sub_32_er_a ", 0xf1f8, 0x9088, { 6, 6, 2}},
{"m68k_op_sub_32_er_ai ", 0xf1f8, 0x9090, { 14, 14, 6}},
{"m68k_op_sub_32_er_pi ", 0xf1f8, 0x9098, { 14, 14, 6}},
{"m68k_op_sub_32_er_pd ", 0xf1f8, 0x90a0, { 16, 16, 7}},
{"m68k_op_sub_32_er_di ", 0xf1f8, 0x90a8, { 18, 18, 7}},
{"m68k_op_sub_32_er_ix ", 0xf1f8, 0x90b0, { 20, 20, 9}},
{"m68k_op_suba_16_d ", 0xf1f8, 0x90c0, { 8, 8, 2}},
{"m68k_op_suba_16_a ", 0xf1f8, 0x90c8, { 8, 8, 2}},
{"m68k_op_suba_16_ai ", 0xf1f8, 0x90d0, { 12, 12, 6}},
{"m68k_op_suba_16_pi ", 0xf1f8, 0x90d8, { 12, 12, 6}},
{"m68k_op_suba_16_pd ", 0xf1f8, 0x90e0, { 14, 14, 7}},
{"m68k_op_suba_16_di ", 0xf1f8, 0x90e8, { 16, 16, 7}},
{"m68k_op_suba_16_ix ", 0xf1f8, 0x90f0, { 18, 18, 9}},
{"m68k_op_subx_8_rr ", 0xf1f8, 0x9100, { 4, 4, 2}},
{"m68k_op_subx_8_mm ", 0xf1f8, 0x9108, { 18, 18, 12}},
{"m68k_op_sub_8_re_ai ", 0xf1f8, 0x9110, { 12, 12, 8}},
{"m68k_op_sub_8_re_pi ", 0xf1f8, 0x9118, { 12, 12, 8}},
{"m68k_op_sub_8_re_pd ", 0xf1f8, 0x9120, { 14, 14, 9}},
{"m68k_op_sub_8_re_di ", 0xf1f8, 0x9128, { 16, 16, 9}},
{"m68k_op_sub_8_re_ix ", 0xf1f8, 0x9130, { 18, 18, 11}},
{"m68k_op_subx_16_rr ", 0xf1f8, 0x9140, { 4, 4, 2}},
{"m68k_op_subx_16_mm ", 0xf1f8, 0x9148, { 18, 18, 12}},
{"m68k_op_sub_16_re_ai ", 0xf1f8, 0x9150, { 12, 12, 8}},
{"m68k_op_sub_16_re_pi ", 0xf1f8, 0x9158, { 12, 12, 8}},
{"m68k_op_sub_16_re_pd ", 0xf1f8, 0x9160, { 14, 14, 9}},
{"m68k_op_sub_16_re_di ", 0xf1f8, 0x9168, { 16, 16, 9}},
{"m68k_op_sub_16_re_ix ", 0xf1f8, 0x9170, { 18, 18, 11}},
{"m68k_op_subx_32_rr ", 0xf1f8, 0x9180, { 8, 6, 2}},
{"m68k_op_subx_32_mm ", 0xf1f8, 0x9188, { 30, 30, 12}},
{"m68k_op_sub_32_re_ai ", 0xf1f8, 0x9190, { 20, 20, 8}},
{"m68k_op_sub_32_re_pi ", 0xf1f8, 0x9198, { 20, 20, 8}},
{"m68k_op_sub_32_re_pd ", 0xf1f8, 0x91a0, { 22, 22, 9}},
{"m68k_op_sub_32_re_di ", 0xf1f8, 0x91a8, { 24, 24, 9}},
{"m68k_op_sub_32_re_ix ", 0xf1f8, 0x91b0, { 26, 26, 11}},
{"m68k_op_suba_32_d ", 0xf1f8, 0x91c0, { 6, 6, 2}},
{"m68k_op_suba_32_a ", 0xf1f8, 0x91c8, { 6, 6, 2}},
{"m68k_op_suba_32_ai ", 0xf1f8, 0x91d0, { 14, 14, 6}},
{"m68k_op_suba_32_pi ", 0xf1f8, 0x91d8, { 14, 14, 6}},
{"m68k_op_suba_32_pd ", 0xf1f8, 0x91e0, { 16, 16, 7}},
{"m68k_op_suba_32_di ", 0xf1f8, 0x91e8, { 18, 18, 7}},
{"m68k_op_suba_32_ix ", 0xf1f8, 0x91f0, { 20, 20, 9}},
{"m68k_op_cmp_8_d ", 0xf1f8, 0xb000, { 4, 4, 2}},
{"m68k_op_cmp_8_ai ", 0xf1f8, 0xb010, { 8, 8, 6}},
{"m68k_op_cmp_8_pi ", 0xf1f8, 0xb018, { 8, 8, 6}},
{"m68k_op_cmp_8_pd ", 0xf1f8, 0xb020, { 10, 10, 7}},
{"m68k_op_cmp_8_di ", 0xf1f8, 0xb028, { 12, 12, 7}},
{"m68k_op_cmp_8_ix ", 0xf1f8, 0xb030, { 14, 14, 9}},
{"m68k_op_cmp_16_d ", 0xf1f8, 0xb040, { 4, 4, 2}},
{"m68k_op_cmp_16_a ", 0xf1f8, 0xb048, { 4, 4, 2}},
{"m68k_op_cmp_16_ai ", 0xf1f8, 0xb050, { 8, 8, 6}},
{"m68k_op_cmp_16_pi ", 0xf1f8, 0xb058, { 8, 8, 6}},
{"m68k_op_cmp_16_pd ", 0xf1f8, 0xb060, { 10, 10, 7}},
{"m68k_op_cmp_16_di ", 0xf1f8, 0xb068, { 12, 12, 7}},
{"m68k_op_cmp_16_ix ", 0xf1f8, 0xb070, { 14, 14, 9}},
{"m68k_op_cmp_32_d ", 0xf1f8, 0xb080, { 6, 6, 2}},
{"m68k_op_cmp_32_a ", 0xf1f8, 0xb088, { 6, 6, 2}},
{"m68k_op_cmp_32_ai ", 0xf1f8, 0xb090, { 14, 14, 6}},
{"m68k_op_cmp_32_pi ", 0xf1f8, 0xb098, { 14, 14, 6}},
{"m68k_op_cmp_32_pd ", 0xf1f8, 0xb0a0, { 16, 16, 7}},
{"m68k_op_cmp_32_di ", 0xf1f8, 0xb0a8, { 18, 18, 7}},
{"m68k_op_cmp_32_ix ", 0xf1f8, 0xb0b0, { 20, 20, 9}},
{"m68k_op_cmpa_16_d ", 0xf1f8, 0xb0c0, { 6, 6, 4}},
{"m68k_op_cmpa_16_a ", 0xf1f8, 0xb0c8, { 6, 6, 4}},
{"m68k_op_cmpa_16_ai ", 0xf1f8, 0xb0d0, { 10, 10, 8}},
{"m68k_op_cmpa_16_pi ", 0xf1f8, 0xb0d8, { 10, 10, 8}},
{"m68k_op_cmpa_16_pd ", 0xf1f8, 0xb0e0, { 12, 12, 9}},
{"m68k_op_cmpa_16_di ", 0xf1f8, 0xb0e8, { 14, 14, 9}},
{"m68k_op_cmpa_16_ix ", 0xf1f8, 0xb0f0, { 16, 16, 11}},
{"m68k_op_eor_8_d ", 0xf1f8, 0xb100, { 4, 4, 2}},
{"m68k_op_cmpm_8 ", 0xf1f8, 0xb108, { 12, 12, 9}},
{"m68k_op_eor_8_ai ", 0xf1f8, 0xb110, { 12, 12, 8}},
{"m68k_op_eor_8_pi ", 0xf1f8, 0xb118, { 12, 12, 8}},
{"m68k_op_eor_8_pd ", 0xf1f8, 0xb120, { 14, 14, 9}},
{"m68k_op_eor_8_di ", 0xf1f8, 0xb128, { 16, 16, 9}},
{"m68k_op_eor_8_ix ", 0xf1f8, 0xb130, { 18, 18, 11}},
{"m68k_op_eor_16_d ", 0xf1f8, 0xb140, { 4, 4, 2}},
{"m68k_op_cmpm_16 ", 0xf1f8, 0xb148, { 12, 12, 9}},
{"m68k_op_eor_16_ai ", 0xf1f8, 0xb150, { 12, 12, 8}},
{"m68k_op_eor_16_pi ", 0xf1f8, 0xb158, { 12, 12, 8}},
{"m68k_op_eor_16_pd ", 0xf1f8, 0xb160, { 14, 14, 9}},
{"m68k_op_eor_16_di ", 0xf1f8, 0xb168, { 16, 16, 9}},
{"m68k_op_eor_16_ix ", 0xf1f8, 0xb170, { 18, 18, 11}},
{"m68k_op_eor_32_d ", 0xf1f8, 0xb180, { 8, 6, 2}},
{"m68k_op_cmpm_32 ", 0xf1f8, 0xb188, { 20, 20, 9}},
{"m68k_op_eor_32_ai ", 0xf1f8, 0xb190, { 20, 20, 8}},
{"m68k_op_eor_32_pi ", 0xf1f8, 0xb198, { 20, 20, 8}},
{"m68k_op_eor_32_pd ", 0xf1f8, 0xb1a0, { 22, 22, 9}},
{"m68k_op_eor_32_di ", 0xf1f8, 0xb1a8, { 24, 24, 9}},
{"m68k_op_eor_32_ix ", 0xf1f8, 0xb1b0, { 26, 26, 11}},
{"m68k_op_cmpa_32_d ", 0xf1f8, 0xb1c0, { 6, 6, 4}},
{"m68k_op_cmpa_32_a ", 0xf1f8, 0xb1c8, { 6, 6, 4}},
{"m68k_op_cmpa_32_ai ", 0xf1f8, 0xb1d0, { 14, 14, 8}},
{"m68k_op_cmpa_32_pi ", 0xf1f8, 0xb1d8, { 14, 14, 8}},
{"m68k_op_cmpa_32_pd ", 0xf1f8, 0xb1e0, { 16, 16, 9}},
{"m68k_op_cmpa_32_di ", 0xf1f8, 0xb1e8, { 18, 18, 9}},
{"m68k_op_cmpa_32_ix ", 0xf1f8, 0xb1f0, { 20, 20, 11}},
{"m68k_op_and_8_er_d ", 0xf1f8, 0xc000, { 4, 4, 2}},
{"m68k_op_and_8_er_ai ", 0xf1f8, 0xc010, { 8, 8, 6}},
{"m68k_op_and_8_er_pi ", 0xf1f8, 0xc018, { 8, 8, 6}},
{"m68k_op_and_8_er_pd ", 0xf1f8, 0xc020, { 10, 10, 7}},
{"m68k_op_and_8_er_di ", 0xf1f8, 0xc028, { 12, 12, 7}},
{"m68k_op_and_8_er_ix ", 0xf1f8, 0xc030, { 14, 14, 9}},
{"m68k_op_and_16_er_d ", 0xf1f8, 0xc040, { 4, 4, 2}},
{"m68k_op_and_16_er_ai ", 0xf1f8, 0xc050, { 8, 8, 6}},
{"m68k_op_and_16_er_pi ", 0xf1f8, 0xc058, { 8, 8, 6}},
{"m68k_op_and_16_er_pd ", 0xf1f8, 0xc060, { 10, 10, 7}},
{"m68k_op_and_16_er_di ", 0xf1f8, 0xc068, { 12, 12, 7}},
{"m68k_op_and_16_er_ix ", 0xf1f8, 0xc070, { 14, 14, 9}},
{"m68k_op_and_32_er_d ", 0xf1f8, 0xc080, { 6, 6, 2}},
{"m68k_op_and_32_er_ai ", 0xf1f8, 0xc090, { 14, 14, 6}},
{"m68k_op_and_32_er_pi ", 0xf1f8, 0xc098, { 14, 14, 6}},
{"m68k_op_and_32_er_pd ", 0xf1f8, 0xc0a0, { 16, 16, 7}},
{"m68k_op_and_32_er_di ", 0xf1f8, 0xc0a8, { 18, 18, 7}},
{"m68k_op_and_32_er_ix ", 0xf1f8, 0xc0b0, { 20, 20, 9}},
{"m68k_op_mulu_16_d ", 0xf1f8, 0xc0c0, { 54, 30, 27}},
{"m68k_op_mulu_16_ai ", 0xf1f8, 0xc0d0, { 58, 34, 31}},
{"m68k_op_mulu_16_pi ", 0xf1f8, 0xc0d8, { 58, 34, 31}},
{"m68k_op_mulu_16_pd ", 0xf1f8, 0xc0e0, { 60, 36, 32}},
{"m68k_op_mulu_16_di ", 0xf1f8, 0xc0e8, { 62, 38, 32}},
{"m68k_op_mulu_16_ix ", 0xf1f8, 0xc0f0, { 64, 40, 34}},
{"m68k_op_abcd_8_rr ", 0xf1f8, 0xc100, { 6, 6, 4}},
{"m68k_op_abcd_8_mm ", 0xf1f8, 0xc108, { 18, 18, 16}},
{"m68k_op_and_8_re_ai ", 0xf1f8, 0xc110, { 12, 12, 8}},
{"m68k_op_and_8_re_pi ", 0xf1f8, 0xc118, { 12, 12, 8}},
{"m68k_op_and_8_re_pd ", 0xf1f8, 0xc120, { 14, 14, 9}},
{"m68k_op_and_8_re_di ", 0xf1f8, 0xc128, { 16, 16, 9}},
{"m68k_op_and_8_re_ix ", 0xf1f8, 0xc130, { 18, 18, 11}},
{"m68k_op_exg_32_dd ", 0xf1f8, 0xc140, { 6, 6, 2}},
{"m68k_op_exg_32_aa ", 0xf1f8, 0xc148, { 6, 6, 2}},
{"m68k_op_and_16_re_ai ", 0xf1f8, 0xc150, { 12, 12, 8}},
{"m68k_op_and_16_re_pi ", 0xf1f8, 0xc158, { 12, 12, 8}},
{"m68k_op_and_16_re_pd ", 0xf1f8, 0xc160, { 14, 14, 9}},
{"m68k_op_and_16_re_di ", 0xf1f8, 0xc168, { 16, 16, 9}},
{"m68k_op_and_16_re_ix ", 0xf1f8, 0xc170, { 18, 18, 11}},
{"m68k_op_exg_32_da ", 0xf1f8, 0xc188, { 6, 6, 2}},
{"m68k_op_and_32_re_ai ", 0xf1f8, 0xc190, { 20, 20, 8}},
{"m68k_op_and_32_re_pi ", 0xf1f8, 0xc198, { 20, 20, 8}},
{"m68k_op_and_32_re_pd ", 0xf1f8, 0xc1a0, { 22, 22, 9}},
{"m68k_op_and_32_re_di ", 0xf1f8, 0xc1a8, { 24, 24, 9}},
{"m68k_op_and_32_re_ix ", 0xf1f8, 0xc1b0, { 26, 26, 11}},
{"m68k_op_muls_16_d ", 0xf1f8, 0xc1c0, { 54, 32, 27}},
{"m68k_op_muls_16_ai ", 0xf1f8, 0xc1d0, { 58, 36, 31}},
{"m68k_op_muls_16_pi ", 0xf1f8, 0xc1d8, { 58, 36, 31}},
{"m68k_op_muls_16_pd ", 0xf1f8, 0xc1e0, { 60, 38, 32}},
{"m68k_op_muls_16_di ", 0xf1f8, 0xc1e8, { 62, 40, 32}},
{"m68k_op_muls_16_ix ", 0xf1f8, 0xc1f0, { 64, 42, 34}},
{"m68k_op_add_8_er_d ", 0xf1f8, 0xd000, { 4, 4, 2}},
{"m68k_op_add_8_er_ai ", 0xf1f8, 0xd010, { 8, 8, 6}},
{"m68k_op_add_8_er_pi ", 0xf1f8, 0xd018, { 8, 8, 6}},
{"m68k_op_add_8_er_pd ", 0xf1f8, 0xd020, { 10, 10, 7}},
{"m68k_op_add_8_er_di ", 0xf1f8, 0xd028, { 12, 12, 7}},
{"m68k_op_add_8_er_ix ", 0xf1f8, 0xd030, { 14, 14, 9}},
{"m68k_op_add_16_er_d ", 0xf1f8, 0xd040, { 4, 4, 2}},
{"m68k_op_add_16_er_a ", 0xf1f8, 0xd048, { 4, 4, 2}},
{"m68k_op_add_16_er_ai ", 0xf1f8, 0xd050, { 8, 8, 6}},
{"m68k_op_add_16_er_pi ", 0xf1f8, 0xd058, { 8, 8, 6}},
{"m68k_op_add_16_er_pd ", 0xf1f8, 0xd060, { 10, 10, 7}},
{"m68k_op_add_16_er_di ", 0xf1f8, 0xd068, { 12, 12, 7}},
{"m68k_op_add_16_er_ix ", 0xf1f8, 0xd070, { 14, 14, 9}},
{"m68k_op_add_32_er_d ", 0xf1f8, 0xd080, { 6, 6, 2}},
{"m68k_op_add_32_er_a ", 0xf1f8, 0xd088, { 6, 6, 2}},
{"m68k_op_add_32_er_ai ", 0xf1f8, 0xd090, { 14, 14, 6}},
{"m68k_op_add_32_er_pi ", 0xf1f8, 0xd098, { 14, 14, 6}},
{"m68k_op_add_32_er_pd ", 0xf1f8, 0xd0a0, { 16, 16, 7}},
{"m68k_op_add_32_er_di ", 0xf1f8, 0xd0a8, { 18, 18, 7}},
{"m68k_op_add_32_er_ix ", 0xf1f8, 0xd0b0, { 20, 20, 9}},
{"m68k_op_adda_16_d ", 0xf1f8, 0xd0c0, { 8, 8, 2}},
{"m68k_op_adda_16_a ", 0xf1f8, 0xd0c8, { 8, 8, 2}},
{"m68k_op_adda_16_ai ", 0xf1f8, 0xd0d0, { 12, 12, 6}},
{"m68k_op_adda_16_pi ", 0xf1f8, 0xd0d8, { 12, 12, 6}},
{"m68k_op_adda_16_pd ", 0xf1f8, 0xd0e0, { 14, 14, 7}},
{"m68k_op_adda_16_di ", 0xf1f8, 0xd0e8, { 16, 16, 7}},
{"m68k_op_adda_16_ix ", 0xf1f8, 0xd0f0, { 18, 18, 9}},
{"m68k_op_addx_8_rr ", 0xf1f8, 0xd100, { 4, 4, 2}},
{"m68k_op_addx_8_mm ", 0xf1f8, 0xd108, { 18, 18, 12}},
{"m68k_op_add_8_re_ai ", 0xf1f8, 0xd110, { 12, 12, 8}},
{"m68k_op_add_8_re_pi ", 0xf1f8, 0xd118, { 12, 12, 8}},
{"m68k_op_add_8_re_pd ", 0xf1f8, 0xd120, { 14, 14, 9}},
{"m68k_op_add_8_re_di ", 0xf1f8, 0xd128, { 16, 16, 9}},
{"m68k_op_add_8_re_ix ", 0xf1f8, 0xd130, { 18, 18, 11}},
{"m68k_op_addx_16_rr ", 0xf1f8, 0xd140, { 4, 4, 2}},
{"m68k_op_addx_16_mm ", 0xf1f8, 0xd148, { 18, 18, 12}},
{"m68k_op_add_16_re_ai ", 0xf1f8, 0xd150, { 12, 12, 8}},
{"m68k_op_add_16_re_pi ", 0xf1f8, 0xd158, { 12, 12, 8}},
{"m68k_op_add_16_re_pd ", 0xf1f8, 0xd160, { 14, 14, 9}},
{"m68k_op_add_16_re_di ", 0xf1f8, 0xd168, { 16, 16, 9}},
{"m68k_op_add_16_re_ix ", 0xf1f8, 0xd170, { 18, 18, 11}},
{"m68k_op_addx_32_rr ", 0xf1f8, 0xd180, { 8, 6, 2}},
{"m68k_op_addx_32_mm ", 0xf1f8, 0xd188, { 30, 30, 12}},
{"m68k_op_add_32_re_ai ", 0xf1f8, 0xd190, { 20, 20, 8}},
{"m68k_op_add_32_re_pi ", 0xf1f8, 0xd198, { 20, 20, 8}},
{"m68k_op_add_32_re_pd ", 0xf1f8, 0xd1a0, { 22, 22, 9}},
{"m68k_op_add_32_re_di ", 0xf1f8, 0xd1a8, { 24, 24, 9}},
{"m68k_op_add_32_re_ix ", 0xf1f8, 0xd1b0, { 26, 26, 11}},
{"m68k_op_adda_32_d ", 0xf1f8, 0xd1c0, { 6, 6, 2}},
{"m68k_op_adda_32_a ", 0xf1f8, 0xd1c8, { 6, 6, 2}},
{"m68k_op_adda_32_ai ", 0xf1f8, 0xd1d0, { 14, 14, 6}},
{"m68k_op_adda_32_pi ", 0xf1f8, 0xd1d8, { 14, 14, 6}},
{"m68k_op_adda_32_pd ", 0xf1f8, 0xd1e0, { 16, 16, 7}},
{"m68k_op_adda_32_di ", 0xf1f8, 0xd1e8, { 18, 18, 7}},
{"m68k_op_adda_32_ix ", 0xf1f8, 0xd1f0, { 20, 20, 9}},
{"m68k_op_asr_8_s ", 0xf1f8, 0xe000, { 6, 6, 6}},
{"m68k_op_lsr_8_s ", 0xf1f8, 0xe008, { 6, 6, 4}},
{"m68k_op_roxr_8_s ", 0xf1f8, 0xe010, { 6, 6, 12}},
{"m68k_op_ror_8_s ", 0xf1f8, 0xe018, { 6, 6, 8}},
{"m68k_op_asr_8_r ", 0xf1f8, 0xe020, { 6, 6, 6}},
{"m68k_op_lsr_8_r ", 0xf1f8, 0xe028, { 6, 6, 6}},
{"m68k_op_roxr_8_r ", 0xf1f8, 0xe030, { 6, 6, 12}},
{"m68k_op_ror_8_r ", 0xf1f8, 0xe038, { 6, 6, 8}},
{"m68k_op_asr_16_s ", 0xf1f8, 0xe040, { 6, 6, 6}},
{"m68k_op_lsr_16_s ", 0xf1f8, 0xe048, { 6, 6, 4}},
{"m68k_op_roxr_16_s ", 0xf1f8, 0xe050, { 6, 6, 12}},
{"m68k_op_ror_16_s ", 0xf1f8, 0xe058, { 6, 6, 8}},
{"m68k_op_asr_16_r ", 0xf1f8, 0xe060, { 6, 6, 6}},
{"m68k_op_lsr_16_r ", 0xf1f8, 0xe068, { 6, 6, 6}},
{"m68k_op_roxr_16_r ", 0xf1f8, 0xe070, { 6, 6, 12}},
{"m68k_op_ror_16_r ", 0xf1f8, 0xe078, { 6, 6, 8}},
{"m68k_op_asr_32_s ", 0xf1f8, 0xe080, { 8, 8, 6}},
{"m68k_op_lsr_32_s ", 0xf1f8, 0xe088, { 8, 8, 4}},
{"m68k_op_roxr_32_s ", 0xf1f8, 0xe090, { 8, 8, 12}},
{"m68k_op_ror_32_s ", 0xf1f8, 0xe098, { 8, 8, 8}},
{"m68k_op_asr_32_r ", 0xf1f8, 0xe0a0, { 8, 8, 6}},
{"m68k_op_lsr_32_r ", 0xf1f8, 0xe0a8, { 8, 8, 6}},
{"m68k_op_roxr_32_r ", 0xf1f8, 0xe0b0, { 8, 8, 12}},
{"m68k_op_ror_32_r ", 0xf1f8, 0xe0b8, { 8, 8, 8}},
{"m68k_op_asl_8_s ", 0xf1f8, 0xe100, { 6, 6, 8}},
{"m68k_op_lsl_8_s ", 0xf1f8, 0xe108, { 6, 6, 4}},
{"m68k_op_roxl_8_s ", 0xf1f8, 0xe110, { 6, 6, 12}},
{"m68k_op_rol_8_s ", 0xf1f8, 0xe118, { 6, 6, 8}},
{"m68k_op_asl_8_r ", 0xf1f8, 0xe120, { 6, 6, 8}},
{"m68k_op_lsl_8_r ", 0xf1f8, 0xe128, { 6, 6, 6}},
{"m68k_op_roxl_8_r ", 0xf1f8, 0xe130, { 6, 6, 12}},
{"m68k_op_rol_8_r ", 0xf1f8, 0xe138, { 6, 6, 8}},
{"m68k_op_asl_16_s ", 0xf1f8, 0xe140, { 6, 6, 8}},
{"m68k_op_lsl_16_s ", 0xf1f8, 0xe148, { 6, 6, 4}},
{"m68k_op_roxl_16_s ", 0xf1f8, 0xe150, { 6, 6, 12}},
{"m68k_op_rol_16_s ", 0xf1f8, 0xe158, { 6, 6, 8}},
{"m68k_op_asl_16_r ", 0xf1f8, 0xe160, { 6, 6, 8}},
{"m68k_op_lsl_16_r ", 0xf1f8, 0xe168, { 6, 6, 6}},
{"m68k_op_roxl_16_r ", 0xf1f8, 0xe170, { 6, 6, 12}},
{"m68k_op_rol_16_r ", 0xf1f8, 0xe178, { 6, 6, 8}},
{"m68k_op_asl_32_s ", 0xf1f8, 0xe180, { 8, 8, 8}},
{"m68k_op_lsl_32_s ", 0xf1f8, 0xe188, { 8, 8, 4}},
{"m68k_op_roxl_32_s ", 0xf1f8, 0xe190, { 8, 8, 12}},
{"m68k_op_rol_32_s ", 0xf1f8, 0xe198, { 8, 8, 8}},
{"m68k_op_asl_32_r ", 0xf1f8, 0xe1a0, { 8, 8, 8}},
{"m68k_op_lsl_32_r ", 0xf1f8, 0xe1a8, { 8, 8, 6}},
{"m68k_op_roxl_32_r ", 0xf1f8, 0xe1b0, { 8, 8, 12}},
{"m68k_op_rol_32_r ", 0xf1f8, 0xe1b8, { 8, 8, 8}},
{"m68k_op_cpdbcc_32 ", 0xf1f8, 0xf048, { 0, 0, 4}},
{"m68k_op_cptrapcc_32 ", 0xf1f8, 0xf078, { 0, 0, 4}},
{"m68k_op_rtm_32 ", 0xfff0, 0x06c0, { 0, 0, 19}},
{"m68k_op_trap ", 0xfff0, 0x4e40, { 4, 4, 4}},
{"m68k_op_btst_8_r_pi7 ", 0xf1ff, 0x011f, { 8, 8, 8}},
{"m68k_op_btst_8_r_pd7 ", 0xf1ff, 0x0127, { 10, 10, 9}},
{"m68k_op_btst_8_r_aw ", 0xf1ff, 0x0138, { 12, 12, 8}},
{"m68k_op_btst_8_r_al ", 0xf1ff, 0x0139, { 16, 16, 8}},
{"m68k_op_btst_8_r_pcdi ", 0xf1ff, 0x013a, { 12, 12, 9}},
{"m68k_op_btst_8_r_pcix ", 0xf1ff, 0x013b, { 14, 14, 11}},
{"m68k_op_btst_8_r_i ", 0xf1ff, 0x013c, { 8, 8, 6}},
{"m68k_op_bchg_8_r_pi7 ", 0xf1ff, 0x015f, { 12, 12, 8}},
{"m68k_op_bchg_8_r_pd7 ", 0xf1ff, 0x0167, { 14, 14, 9}},
{"m68k_op_bchg_8_r_aw ", 0xf1ff, 0x0178, { 16, 16, 8}},
{"m68k_op_bchg_8_r_al ", 0xf1ff, 0x0179, { 20, 20, 8}},
{"m68k_op_bclr_8_r_pi7 ", 0xf1ff, 0x019f, { 12, 14, 8}},
{"m68k_op_bclr_8_r_pd7 ", 0xf1ff, 0x01a7, { 14, 16, 9}},
{"m68k_op_bclr_8_r_aw ", 0xf1ff, 0x01b8, { 16, 18, 8}},
{"m68k_op_bclr_8_r_al ", 0xf1ff, 0x01b9, { 20, 22, 8}},
{"m68k_op_bset_8_r_pi7 ", 0xf1ff, 0x01df, { 12, 12, 8}},
{"m68k_op_bset_8_r_pd7 ", 0xf1ff, 0x01e7, { 14, 14, 9}},
{"m68k_op_bset_8_r_aw ", 0xf1ff, 0x01f8, { 16, 16, 8}},
{"m68k_op_bset_8_r_al ", 0xf1ff, 0x01f9, { 20, 20, 8}},
{"m68k_op_move_8_d_pi7 ", 0xf1ff, 0x101f, { 8, 8, 6}},
{"m68k_op_move_8_d_pd7 ", 0xf1ff, 0x1027, { 10, 10, 7}},
{"m68k_op_move_8_d_aw ", 0xf1ff, 0x1038, { 12, 12, 6}},
{"m68k_op_move_8_d_al ", 0xf1ff, 0x1039, { 16, 16, 6}},
{"m68k_op_move_8_d_pcdi ", 0xf1ff, 0x103a, { 12, 12, 7}},
{"m68k_op_move_8_d_pcix ", 0xf1ff, 0x103b, { 14, 14, 9}},
{"m68k_op_move_8_d_i ", 0xf1ff, 0x103c, { 8, 8, 4}},
{"m68k_op_move_8_ai_pi7 ", 0xf1ff, 0x109f, { 12, 12, 8}},
{"m68k_op_move_8_ai_pd7 ", 0xf1ff, 0x10a7, { 14, 14, 9}},
{"m68k_op_move_8_ai_aw ", 0xf1ff, 0x10b8, { 16, 16, 8}},
{"m68k_op_move_8_ai_al ", 0xf1ff, 0x10b9, { 20, 20, 8}},
{"m68k_op_move_8_ai_pcdi ", 0xf1ff, 0x10ba, { 16, 16, 9}},
{"m68k_op_move_8_ai_pcix ", 0xf1ff, 0x10bb, { 18, 18, 11}},
{"m68k_op_move_8_ai_i ", 0xf1ff, 0x10bc, { 12, 12, 6}},
{"m68k_op_move_8_pi_pi7 ", 0xf1ff, 0x10df, { 12, 12, 8}},
{"m68k_op_move_8_pi_pd7 ", 0xf1ff, 0x10e7, { 14, 14, 9}},
{"m68k_op_move_8_pi_aw ", 0xf1ff, 0x10f8, { 16, 16, 8}},
{"m68k_op_move_8_pi_al ", 0xf1ff, 0x10f9, { 20, 20, 8}},
{"m68k_op_move_8_pi_pcdi ", 0xf1ff, 0x10fa, { 16, 16, 9}},
{"m68k_op_move_8_pi_pcix ", 0xf1ff, 0x10fb, { 18, 18, 11}},
{"m68k_op_move_8_pi_i ", 0xf1ff, 0x10fc, { 12, 12, 6}},
{"m68k_op_move_8_pd_pi7 ", 0xf1ff, 0x111f, { 12, 12, 9}},
{"m68k_op_move_8_pd_pd7 ", 0xf1ff, 0x1127, { 14, 14, 10}},
{"m68k_op_move_8_pd_aw ", 0xf1ff, 0x1138, { 16, 16, 9}},
{"m68k_op_move_8_pd_al ", 0xf1ff, 0x1139, { 20, 20, 9}},
{"m68k_op_move_8_pd_pcdi ", 0xf1ff, 0x113a, { 16, 16, 10}},
{"m68k_op_move_8_pd_pcix ", 0xf1ff, 0x113b, { 18, 18, 12}},
{"m68k_op_move_8_pd_i ", 0xf1ff, 0x113c, { 12, 12, 7}},
{"m68k_op_move_8_di_pi7 ", 0xf1ff, 0x115f, { 16, 16, 9}},
{"m68k_op_move_8_di_pd7 ", 0xf1ff, 0x1167, { 18, 18, 10}},
{"m68k_op_move_8_di_aw ", 0xf1ff, 0x1178, { 20, 20, 9}},
{"m68k_op_move_8_di_al ", 0xf1ff, 0x1179, { 24, 24, 9}},
{"m68k_op_move_8_di_pcdi ", 0xf1ff, 0x117a, { 20, 20, 10}},
{"m68k_op_move_8_di_pcix ", 0xf1ff, 0x117b, { 22, 22, 12}},
{"m68k_op_move_8_di_i ", 0xf1ff, 0x117c, { 16, 16, 7}},
{"m68k_op_move_8_ix_pi7 ", 0xf1ff, 0x119f, { 18, 18, 11}},
{"m68k_op_move_8_ix_pd7 ", 0xf1ff, 0x11a7, { 20, 20, 12}},
{"m68k_op_move_8_ix_aw ", 0xf1ff, 0x11b8, { 22, 22, 11}},
{"m68k_op_move_8_ix_al ", 0xf1ff, 0x11b9, { 26, 26, 11}},
{"m68k_op_move_8_ix_pcdi ", 0xf1ff, 0x11ba, { 22, 22, 12}},
{"m68k_op_move_8_ix_pcix ", 0xf1ff, 0x11bb, { 24, 24, 14}},
{"m68k_op_move_8_ix_i ", 0xf1ff, 0x11bc, { 18, 18, 9}},
{"m68k_op_move_32_d_aw ", 0xf1ff, 0x2038, { 16, 16, 6}},
{"m68k_op_move_32_d_al ", 0xf1ff, 0x2039, { 20, 20, 6}},
{"m68k_op_move_32_d_pcdi ", 0xf1ff, 0x203a, { 16, 16, 7}},
{"m68k_op_move_32_d_pcix ", 0xf1ff, 0x203b, { 18, 18, 9}},
{"m68k_op_move_32_d_i ", 0xf1ff, 0x203c, { 12, 12, 6}},
{"m68k_op_movea_32_aw ", 0xf1ff, 0x2078, { 16, 16, 6}},
{"m68k_op_movea_32_al ", 0xf1ff, 0x2079, { 20, 20, 6}},
{"m68k_op_movea_32_pcdi ", 0xf1ff, 0x207a, { 16, 16, 7}},
{"m68k_op_movea_32_pcix ", 0xf1ff, 0x207b, { 18, 18, 9}},
{"m68k_op_movea_32_i ", 0xf1ff, 0x207c, { 12, 12, 6}},
{"m68k_op_move_32_ai_aw ", 0xf1ff, 0x20b8, { 24, 24, 8}},
{"m68k_op_move_32_ai_al ", 0xf1ff, 0x20b9, { 28, 28, 8}},
{"m68k_op_move_32_ai_pcdi ", 0xf1ff, 0x20ba, { 24, 24, 9}},
{"m68k_op_move_32_ai_pcix ", 0xf1ff, 0x20bb, { 26, 26, 11}},
{"m68k_op_move_32_ai_i ", 0xf1ff, 0x20bc, { 20, 20, 8}},
{"m68k_op_move_32_pi_aw ", 0xf1ff, 0x20f8, { 24, 24, 8}},
{"m68k_op_move_32_pi_al ", 0xf1ff, 0x20f9, { 28, 28, 8}},
{"m68k_op_move_32_pi_pcdi ", 0xf1ff, 0x20fa, { 24, 24, 9}},
{"m68k_op_move_32_pi_pcix ", 0xf1ff, 0x20fb, { 26, 26, 11}},
{"m68k_op_move_32_pi_i ", 0xf1ff, 0x20fc, { 20, 20, 8}},
{"m68k_op_move_32_pd_aw ", 0xf1ff, 0x2138, { 24, 26, 9}},
{"m68k_op_move_32_pd_al ", 0xf1ff, 0x2139, { 28, 30, 9}},
{"m68k_op_move_32_pd_pcdi ", 0xf1ff, 0x213a, { 24, 26, 10}},
{"m68k_op_move_32_pd_pcix ", 0xf1ff, 0x213b, { 26, 28, 12}},
{"m68k_op_move_32_pd_i ", 0xf1ff, 0x213c, { 20, 22, 9}},
{"m68k_op_move_32_di_aw ", 0xf1ff, 0x2178, { 28, 28, 9}},
{"m68k_op_move_32_di_al ", 0xf1ff, 0x2179, { 32, 32, 9}},
{"m68k_op_move_32_di_pcdi ", 0xf1ff, 0x217a, { 28, 28, 10}},
{"m68k_op_move_32_di_pcix ", 0xf1ff, 0x217b, { 30, 30, 12}},
{"m68k_op_move_32_di_i ", 0xf1ff, 0x217c, { 24, 24, 9}},
{"m68k_op_move_32_ix_aw ", 0xf1ff, 0x21b8, { 30, 30, 11}},
{"m68k_op_move_32_ix_al ", 0xf1ff, 0x21b9, { 34, 34, 11}},
{"m68k_op_move_32_ix_pcdi ", 0xf1ff, 0x21ba, { 30, 30, 12}},
{"m68k_op_move_32_ix_pcix ", 0xf1ff, 0x21bb, { 32, 32, 14}},
{"m68k_op_move_32_ix_i ", 0xf1ff, 0x21bc, { 26, 26, 11}},
{"m68k_op_move_16_d_aw ", 0xf1ff, 0x3038, { 12, 12, 6}},
{"m68k_op_move_16_d_al ", 0xf1ff, 0x3039, { 16, 16, 6}},
{"m68k_op_move_16_d_pcdi ", 0xf1ff, 0x303a, { 12, 12, 7}},
{"m68k_op_move_16_d_pcix ", 0xf1ff, 0x303b, { 14, 14, 9}},
{"m68k_op_move_16_d_i ", 0xf1ff, 0x303c, { 8, 8, 4}},
{"m68k_op_movea_16_aw ", 0xf1ff, 0x3078, { 12, 12, 6}},
{"m68k_op_movea_16_al ", 0xf1ff, 0x3079, { 16, 16, 6}},
{"m68k_op_movea_16_pcdi ", 0xf1ff, 0x307a, { 12, 12, 7}},
{"m68k_op_movea_16_pcix ", 0xf1ff, 0x307b, { 14, 14, 9}},
{"m68k_op_movea_16_i ", 0xf1ff, 0x307c, { 8, 8, 4}},
{"m68k_op_move_16_ai_aw ", 0xf1ff, 0x30b8, { 16, 16, 8}},
{"m68k_op_move_16_ai_al ", 0xf1ff, 0x30b9, { 20, 20, 8}},
{"m68k_op_move_16_ai_pcdi ", 0xf1ff, 0x30ba, { 16, 16, 9}},
{"m68k_op_move_16_ai_pcix ", 0xf1ff, 0x30bb, { 18, 18, 11}},
{"m68k_op_move_16_ai_i ", 0xf1ff, 0x30bc, { 12, 12, 6}},
{"m68k_op_move_16_pi_aw ", 0xf1ff, 0x30f8, { 16, 16, 8}},
{"m68k_op_move_16_pi_al ", 0xf1ff, 0x30f9, { 20, 20, 8}},
{"m68k_op_move_16_pi_pcdi ", 0xf1ff, 0x30fa, { 16, 16, 9}},
{"m68k_op_move_16_pi_pcix ", 0xf1ff, 0x30fb, { 18, 18, 11}},
{"m68k_op_move_16_pi_i ", 0xf1ff, 0x30fc, { 12, 12, 6}},
{"m68k_op_move_16_pd_aw ", 0xf1ff, 0x3138, { 16, 16, 9}},
{"m68k_op_move_16_pd_al ", 0xf1ff, 0x3139, { 20, 20, 9}},
{"m68k_op_move_16_pd_pcdi ", 0xf1ff, 0x313a, { 16, 16, 10}},
{"m68k_op_move_16_pd_pcix ", 0xf1ff, 0x313b, { 18, 18, 12}},
{"m68k_op_move_16_pd_i ", 0xf1ff, 0x313c, { 12, 12, 7}},
{"m68k_op_move_16_di_aw ", 0xf1ff, 0x3178, { 20, 20, 9}},
{"m68k_op_move_16_di_al ", 0xf1ff, 0x3179, { 24, 24, 9}},
{"m68k_op_move_16_di_pcdi ", 0xf1ff, 0x317a, { 20, 20, 10}},
{"m68k_op_move_16_di_pcix ", 0xf1ff, 0x317b, { 22, 22, 12}},
{"m68k_op_move_16_di_i ", 0xf1ff, 0x317c, { 16, 16, 7}},
{"m68k_op_move_16_ix_aw ", 0xf1ff, 0x31b8, { 22, 22, 11}},
{"m68k_op_move_16_ix_al ", 0xf1ff, 0x31b9, { 26, 26, 11}},
{"m68k_op_move_16_ix_pcdi ", 0xf1ff, 0x31ba, { 22, 22, 12}},
{"m68k_op_move_16_ix_pcix ", 0xf1ff, 0x31bb, { 24, 24, 14}},
{"m68k_op_move_16_ix_i ", 0xf1ff, 0x31bc, { 18, 18, 9}},
{"m68k_op_chk_32_aw ", 0xf1ff, 0x4138, { 0, 0, 12}},
{"m68k_op_chk_32_al ", 0xf1ff, 0x4139, { 0, 0, 12}},
{"m68k_op_chk_32_pcdi ", 0xf1ff, 0x413a, { 0, 0, 13}},
{"m68k_op_chk_32_pcix ", 0xf1ff, 0x413b, { 0, 0, 15}},
{"m68k_op_chk_32_i ", 0xf1ff, 0x413c, { 0, 0, 12}},
{"m68k_op_chk_16_aw ", 0xf1ff, 0x41b8, { 18, 16, 12}},
{"m68k_op_chk_16_al ", 0xf1ff, 0x41b9, { 22, 20, 12}},
{"m68k_op_chk_16_pcdi ", 0xf1ff, 0x41ba, { 18, 16, 13}},
{"m68k_op_chk_16_pcix ", 0xf1ff, 0x41bb, { 20, 18, 15}},
{"m68k_op_chk_16_i ", 0xf1ff, 0x41bc, { 14, 12, 10}},
{"m68k_op_lea_32_aw ", 0xf1ff, 0x41f8, { 8, 8, 6}},
{"m68k_op_lea_32_al ", 0xf1ff, 0x41f9, { 12, 12, 6}},
{"m68k_op_lea_32_pcdi ", 0xf1ff, 0x41fa, { 8, 8, 7}},
{"m68k_op_lea_32_pcix ", 0xf1ff, 0x41fb, { 12, 12, 9}},
{"m68k_op_addq_8_pi7 ", 0xf1ff, 0x501f, { 12, 12, 8}},
{"m68k_op_addq_8_pd7 ", 0xf1ff, 0x5027, { 14, 14, 9}},
{"m68k_op_addq_8_aw ", 0xf1ff, 0x5038, { 16, 16, 8}},
{"m68k_op_addq_8_al ", 0xf1ff, 0x5039, { 20, 20, 8}},
{"m68k_op_addq_16_aw ", 0xf1ff, 0x5078, { 16, 16, 8}},
{"m68k_op_addq_16_al ", 0xf1ff, 0x5079, { 20, 20, 8}},
{"m68k_op_addq_32_aw ", 0xf1ff, 0x50b8, { 24, 24, 8}},
{"m68k_op_addq_32_al ", 0xf1ff, 0x50b9, { 28, 28, 8}},
{"m68k_op_subq_8_pi7 ", 0xf1ff, 0x511f, { 12, 12, 8}},
{"m68k_op_subq_8_pd7 ", 0xf1ff, 0x5127, { 14, 14, 9}},
{"m68k_op_subq_8_aw ", 0xf1ff, 0x5138, { 16, 16, 8}},
{"m68k_op_subq_8_al ", 0xf1ff, 0x5139, { 20, 20, 8}},
{"m68k_op_subq_16_aw ", 0xf1ff, 0x5178, { 16, 16, 8}},
{"m68k_op_subq_16_al ", 0xf1ff, 0x5179, { 20, 20, 8}},
{"m68k_op_subq_32_aw ", 0xf1ff, 0x51b8, { 24, 24, 8}},
{"m68k_op_subq_32_al ", 0xf1ff, 0x51b9, { 28, 28, 8}},
{"m68k_op_or_8_er_pi7 ", 0xf1ff, 0x801f, { 8, 8, 6}},
{"m68k_op_or_8_er_pd7 ", 0xf1ff, 0x8027, { 10, 10, 7}},
{"m68k_op_or_8_er_aw ", 0xf1ff, 0x8038, { 12, 12, 6}},
{"m68k_op_or_8_er_al ", 0xf1ff, 0x8039, { 16, 16, 6}},
{"m68k_op_or_8_er_pcdi ", 0xf1ff, 0x803a, { 12, 12, 7}},
{"m68k_op_or_8_er_pcix ", 0xf1ff, 0x803b, { 14, 14, 9}},
{"m68k_op_or_8_er_i ", 0xf1ff, 0x803c, { 10, 8, 4}},
{"m68k_op_or_16_er_aw ", 0xf1ff, 0x8078, { 12, 12, 6}},
{"m68k_op_or_16_er_al ", 0xf1ff, 0x8079, { 16, 16, 6}},
{"m68k_op_or_16_er_pcdi ", 0xf1ff, 0x807a, { 12, 12, 7}},
{"m68k_op_or_16_er_pcix ", 0xf1ff, 0x807b, { 14, 14, 9}},
{"m68k_op_or_16_er_i ", 0xf1ff, 0x807c, { 10, 8, 4}},
{"m68k_op_or_32_er_aw ", 0xf1ff, 0x80b8, { 18, 18, 6}},
{"m68k_op_or_32_er_al ", 0xf1ff, 0x80b9, { 22, 22, 6}},
{"m68k_op_or_32_er_pcdi ", 0xf1ff, 0x80ba, { 18, 18, 7}},
{"m68k_op_or_32_er_pcix ", 0xf1ff, 0x80bb, { 20, 20, 9}},
{"m68k_op_or_32_er_i ", 0xf1ff, 0x80bc, { 16, 14, 6}},
{"m68k_op_divu_16_aw ", 0xf1ff, 0x80f8, {148, 116, 48}},
{"m68k_op_divu_16_al ", 0xf1ff, 0x80f9, {152, 120, 48}},
{"m68k_op_divu_16_pcdi ", 0xf1ff, 0x80fa, {148, 116, 49}},
{"m68k_op_divu_16_pcix ", 0xf1ff, 0x80fb, {150, 118, 51}},
{"m68k_op_divu_16_i ", 0xf1ff, 0x80fc, {144, 112, 46}},
{"m68k_op_sbcd_8_mm_ay7 ", 0xf1ff, 0x810f, { 18, 18, 16}},
{"m68k_op_or_8_re_pi7 ", 0xf1ff, 0x811f, { 12, 12, 8}},
{"m68k_op_or_8_re_pd7 ", 0xf1ff, 0x8127, { 14, 14, 9}},
{"m68k_op_or_8_re_aw ", 0xf1ff, 0x8138, { 16, 16, 8}},
{"m68k_op_or_8_re_al ", 0xf1ff, 0x8139, { 20, 20, 8}},
{"m68k_op_pack_16_mm_ay7 ", 0xf1ff, 0x814f, { 0, 0, 13}},
{"m68k_op_or_16_re_aw ", 0xf1ff, 0x8178, { 16, 16, 8}},
{"m68k_op_or_16_re_al ", 0xf1ff, 0x8179, { 20, 20, 8}},
{"m68k_op_unpk_16_mm_ay7 ", 0xf1ff, 0x818f, { 0, 0, 13}},
{"m68k_op_or_32_re_aw ", 0xf1ff, 0x81b8, { 24, 24, 8}},
{"m68k_op_or_32_re_al ", 0xf1ff, 0x81b9, { 28, 28, 8}},
{"m68k_op_divs_16_aw ", 0xf1ff, 0x81f8, {166, 130, 60}},
{"m68k_op_divs_16_al ", 0xf1ff, 0x81f9, {170, 134, 60}},
{"m68k_op_divs_16_pcdi ", 0xf1ff, 0x81fa, {166, 130, 61}},
{"m68k_op_divs_16_pcix ", 0xf1ff, 0x81fb, {168, 132, 63}},
{"m68k_op_divs_16_i ", 0xf1ff, 0x81fc, {162, 126, 58}},
{"m68k_op_sub_8_er_pi7 ", 0xf1ff, 0x901f, { 8, 8, 6}},
{"m68k_op_sub_8_er_pd7 ", 0xf1ff, 0x9027, { 10, 10, 7}},
{"m68k_op_sub_8_er_aw ", 0xf1ff, 0x9038, { 12, 12, 6}},
{"m68k_op_sub_8_er_al ", 0xf1ff, 0x9039, { 16, 16, 6}},
{"m68k_op_sub_8_er_pcdi ", 0xf1ff, 0x903a, { 12, 12, 7}},
{"m68k_op_sub_8_er_pcix ", 0xf1ff, 0x903b, { 14, 14, 9}},
{"m68k_op_sub_8_er_i ", 0xf1ff, 0x903c, { 10, 8, 4}},
{"m68k_op_sub_16_er_aw ", 0xf1ff, 0x9078, { 12, 12, 6}},
{"m68k_op_sub_16_er_al ", 0xf1ff, 0x9079, { 16, 16, 6}},
{"m68k_op_sub_16_er_pcdi ", 0xf1ff, 0x907a, { 12, 12, 7}},
{"m68k_op_sub_16_er_pcix ", 0xf1ff, 0x907b, { 14, 14, 9}},
{"m68k_op_sub_16_er_i ", 0xf1ff, 0x907c, { 10, 8, 4}},
{"m68k_op_sub_32_er_aw ", 0xf1ff, 0x90b8, { 18, 18, 6}},
{"m68k_op_sub_32_er_al ", 0xf1ff, 0x90b9, { 22, 22, 6}},
{"m68k_op_sub_32_er_pcdi ", 0xf1ff, 0x90ba, { 18, 18, 7}},
{"m68k_op_sub_32_er_pcix ", 0xf1ff, 0x90bb, { 20, 20, 9}},
{"m68k_op_sub_32_er_i ", 0xf1ff, 0x90bc, { 16, 14, 6}},
{"m68k_op_suba_16_aw ", 0xf1ff, 0x90f8, { 16, 16, 6}},
{"m68k_op_suba_16_al ", 0xf1ff, 0x90f9, { 20, 20, 6}},
{"m68k_op_suba_16_pcdi ", 0xf1ff, 0x90fa, { 16, 16, 7}},
{"m68k_op_suba_16_pcix ", 0xf1ff, 0x90fb, { 18, 18, 9}},
{"m68k_op_suba_16_i ", 0xf1ff, 0x90fc, { 14, 12, 4}},
{"m68k_op_subx_8_mm_ay7 ", 0xf1ff, 0x910f, { 18, 18, 12}},
{"m68k_op_sub_8_re_pi7 ", 0xf1ff, 0x911f, { 12, 12, 8}},
{"m68k_op_sub_8_re_pd7 ", 0xf1ff, 0x9127, { 14, 14, 9}},
{"m68k_op_sub_8_re_aw ", 0xf1ff, 0x9138, { 16, 16, 8}},
{"m68k_op_sub_8_re_al ", 0xf1ff, 0x9139, { 20, 20, 8}},
{"m68k_op_sub_16_re_aw ", 0xf1ff, 0x9178, { 16, 16, 8}},
{"m68k_op_sub_16_re_al ", 0xf1ff, 0x9179, { 20, 20, 8}},
{"m68k_op_sub_32_re_aw ", 0xf1ff, 0x91b8, { 24, 24, 8}},
{"m68k_op_sub_32_re_al ", 0xf1ff, 0x91b9, { 28, 28, 8}},
{"m68k_op_suba_32_aw ", 0xf1ff, 0x91f8, { 18, 18, 6}},
{"m68k_op_suba_32_al ", 0xf1ff, 0x91f9, { 22, 22, 6}},
{"m68k_op_suba_32_pcdi ", 0xf1ff, 0x91fa, { 18, 18, 7}},
{"m68k_op_suba_32_pcix ", 0xf1ff, 0x91fb, { 20, 20, 9}},
{"m68k_op_suba_32_i ", 0xf1ff, 0x91fc, { 16, 14, 6}},
{"m68k_op_cmp_8_pi7 ", 0xf1ff, 0xb01f, { 8, 8, 6}},
{"m68k_op_cmp_8_pd7 ", 0xf1ff, 0xb027, { 10, 10, 7}},
{"m68k_op_cmp_8_aw ", 0xf1ff, 0xb038, { 12, 12, 6}},
{"m68k_op_cmp_8_al ", 0xf1ff, 0xb039, { 16, 16, 6}},
{"m68k_op_cmp_8_pcdi ", 0xf1ff, 0xb03a, { 12, 12, 7}},
{"m68k_op_cmp_8_pcix ", 0xf1ff, 0xb03b, { 14, 14, 9}},
{"m68k_op_cmp_8_i ", 0xf1ff, 0xb03c, { 8, 8, 4}},
{"m68k_op_cmp_16_aw ", 0xf1ff, 0xb078, { 12, 12, 6}},
{"m68k_op_cmp_16_al ", 0xf1ff, 0xb079, { 16, 16, 6}},
{"m68k_op_cmp_16_pcdi ", 0xf1ff, 0xb07a, { 12, 12, 7}},
{"m68k_op_cmp_16_pcix ", 0xf1ff, 0xb07b, { 14, 14, 9}},
{"m68k_op_cmp_16_i ", 0xf1ff, 0xb07c, { 8, 8, 4}},
{"m68k_op_cmp_32_aw ", 0xf1ff, 0xb0b8, { 18, 18, 6}},
{"m68k_op_cmp_32_al ", 0xf1ff, 0xb0b9, { 22, 22, 6}},
{"m68k_op_cmp_32_pcdi ", 0xf1ff, 0xb0ba, { 18, 18, 7}},
{"m68k_op_cmp_32_pcix ", 0xf1ff, 0xb0bb, { 20, 20, 9}},
{"m68k_op_cmp_32_i ", 0xf1ff, 0xb0bc, { 14, 14, 6}},
{"m68k_op_cmpa_16_aw ", 0xf1ff, 0xb0f8, { 14, 14, 8}},
{"m68k_op_cmpa_16_al ", 0xf1ff, 0xb0f9, { 18, 18, 8}},
{"m68k_op_cmpa_16_pcdi ", 0xf1ff, 0xb0fa, { 14, 14, 9}},
{"m68k_op_cmpa_16_pcix ", 0xf1ff, 0xb0fb, { 16, 16, 11}},
{"m68k_op_cmpa_16_i ", 0xf1ff, 0xb0fc, { 10, 10, 6}},
{"m68k_op_cmpm_8_ay7 ", 0xf1ff, 0xb10f, { 12, 12, 9}},
{"m68k_op_eor_8_pi7 ", 0xf1ff, 0xb11f, { 12, 12, 8}},
{"m68k_op_eor_8_pd7 ", 0xf1ff, 0xb127, { 14, 14, 9}},
{"m68k_op_eor_8_aw ", 0xf1ff, 0xb138, { 16, 16, 8}},
{"m68k_op_eor_8_al ", 0xf1ff, 0xb139, { 20, 20, 8}},
{"m68k_op_eor_16_aw ", 0xf1ff, 0xb178, { 16, 16, 8}},
{"m68k_op_eor_16_al ", 0xf1ff, 0xb179, { 20, 20, 8}},
{"m68k_op_eor_32_aw ", 0xf1ff, 0xb1b8, { 24, 24, 8}},
{"m68k_op_eor_32_al ", 0xf1ff, 0xb1b9, { 28, 28, 8}},
{"m68k_op_cmpa_32_aw ", 0xf1ff, 0xb1f8, { 18, 18, 8}},
{"m68k_op_cmpa_32_al ", 0xf1ff, 0xb1f9, { 22, 22, 8}},
{"m68k_op_cmpa_32_pcdi ", 0xf1ff, 0xb1fa, { 18, 18, 9}},
{"m68k_op_cmpa_32_pcix ", 0xf1ff, 0xb1fb, { 20, 20, 11}},
{"m68k_op_cmpa_32_i ", 0xf1ff, 0xb1fc, { 14, 14, 8}},
{"m68k_op_and_8_er_pi7 ", 0xf1ff, 0xc01f, { 8, 8, 6}},
{"m68k_op_and_8_er_pd7 ", 0xf1ff, 0xc027, { 10, 10, 7}},
{"m68k_op_and_8_er_aw ", 0xf1ff, 0xc038, { 12, 12, 6}},
{"m68k_op_and_8_er_al ", 0xf1ff, 0xc039, { 16, 16, 6}},
{"m68k_op_and_8_er_pcdi ", 0xf1ff, 0xc03a, { 12, 12, 7}},
{"m68k_op_and_8_er_pcix ", 0xf1ff, 0xc03b, { 14, 14, 9}},
{"m68k_op_and_8_er_i ", 0xf1ff, 0xc03c, { 10, 8, 4}},
{"m68k_op_and_16_er_aw ", 0xf1ff, 0xc078, { 12, 12, 6}},
{"m68k_op_and_16_er_al ", 0xf1ff, 0xc079, { 16, 16, 6}},
{"m68k_op_and_16_er_pcdi ", 0xf1ff, 0xc07a, { 12, 12, 7}},
{"m68k_op_and_16_er_pcix ", 0xf1ff, 0xc07b, { 14, 14, 9}},
{"m68k_op_and_16_er_i ", 0xf1ff, 0xc07c, { 10, 8, 4}},
{"m68k_op_and_32_er_aw ", 0xf1ff, 0xc0b8, { 18, 18, 6}},
{"m68k_op_and_32_er_al ", 0xf1ff, 0xc0b9, { 22, 22, 6}},
{"m68k_op_and_32_er_pcdi ", 0xf1ff, 0xc0ba, { 18, 18, 7}},
{"m68k_op_and_32_er_pcix ", 0xf1ff, 0xc0bb, { 20, 20, 9}},
{"m68k_op_and_32_er_i ", 0xf1ff, 0xc0bc, { 16, 14, 6}},
{"m68k_op_mulu_16_aw ", 0xf1ff, 0xc0f8, { 62, 38, 31}},
{"m68k_op_mulu_16_al ", 0xf1ff, 0xc0f9, { 66, 42, 31}},
{"m68k_op_mulu_16_pcdi ", 0xf1ff, 0xc0fa, { 62, 38, 32}},
{"m68k_op_mulu_16_pcix ", 0xf1ff, 0xc0fb, { 64, 40, 34}},
{"m68k_op_mulu_16_i ", 0xf1ff, 0xc0fc, { 58, 34, 29}},
{"m68k_op_abcd_8_mm_ay7 ", 0xf1ff, 0xc10f, { 18, 18, 16}},
{"m68k_op_and_8_re_pi7 ", 0xf1ff, 0xc11f, { 12, 12, 8}},
{"m68k_op_and_8_re_pd7 ", 0xf1ff, 0xc127, { 14, 14, 9}},
{"m68k_op_and_8_re_aw ", 0xf1ff, 0xc138, { 16, 16, 8}},
{"m68k_op_and_8_re_al ", 0xf1ff, 0xc139, { 20, 20, 8}},
{"m68k_op_and_16_re_aw ", 0xf1ff, 0xc178, { 16, 16, 8}},
{"m68k_op_and_16_re_al ", 0xf1ff, 0xc179, { 20, 20, 8}},
{"m68k_op_and_32_re_aw ", 0xf1ff, 0xc1b8, { 24, 24, 8}},
{"m68k_op_and_32_re_al ", 0xf1ff, 0xc1b9, { 28, 28, 8}},
{"m68k_op_muls_16_aw ", 0xf1ff, 0xc1f8, { 62, 40, 31}},
{"m68k_op_muls_16_al ", 0xf1ff, 0xc1f9, { 66, 44, 31}},
{"m68k_op_muls_16_pcdi ", 0xf1ff, 0xc1fa, { 62, 40, 32}},
{"m68k_op_muls_16_pcix ", 0xf1ff, 0xc1fb, { 64, 42, 34}},
{"m68k_op_muls_16_i ", 0xf1ff, 0xc1fc, { 58, 36, 29}},
{"m68k_op_add_8_er_pi7 ", 0xf1ff, 0xd01f, { 8, 8, 6}},
{"m68k_op_add_8_er_pd7 ", 0xf1ff, 0xd027, { 10, 10, 7}},
{"m68k_op_add_8_er_aw ", 0xf1ff, 0xd038, { 12, 12, 6}},
{"m68k_op_add_8_er_al ", 0xf1ff, 0xd039, { 16, 16, 6}},
{"m68k_op_add_8_er_pcdi ", 0xf1ff, 0xd03a, { 12, 12, 7}},
{"m68k_op_add_8_er_pcix ", 0xf1ff, 0xd03b, { 14, 14, 9}},
{"m68k_op_add_8_er_i ", 0xf1ff, 0xd03c, { 10, 8, 4}},
{"m68k_op_add_16_er_aw ", 0xf1ff, 0xd078, { 12, 12, 6}},
{"m68k_op_add_16_er_al ", 0xf1ff, 0xd079, { 16, 16, 6}},
{"m68k_op_add_16_er_pcdi ", 0xf1ff, 0xd07a, { 12, 12, 7}},
{"m68k_op_add_16_er_pcix ", 0xf1ff, 0xd07b, { 14, 14, 9}},
{"m68k_op_add_16_er_i ", 0xf1ff, 0xd07c, { 10, 8, 4}},
{"m68k_op_add_32_er_aw ", 0xf1ff, 0xd0b8, { 18, 18, 6}},
{"m68k_op_add_32_er_al ", 0xf1ff, 0xd0b9, { 22, 22, 6}},
{"m68k_op_add_32_er_pcdi ", 0xf1ff, 0xd0ba, { 18, 18, 7}},
{"m68k_op_add_32_er_pcix ", 0xf1ff, 0xd0bb, { 20, 20, 9}},
{"m68k_op_add_32_er_i ", 0xf1ff, 0xd0bc, { 16, 14, 6}},
{"m68k_op_adda_16_aw ", 0xf1ff, 0xd0f8, { 16, 16, 6}},
{"m68k_op_adda_16_al ", 0xf1ff, 0xd0f9, { 20, 20, 6}},
{"m68k_op_adda_16_pcdi ", 0xf1ff, 0xd0fa, { 16, 16, 7}},
{"m68k_op_adda_16_pcix ", 0xf1ff, 0xd0fb, { 18, 18, 9}},
{"m68k_op_adda_16_i ", 0xf1ff, 0xd0fc, { 14, 12, 4}},
{"m68k_op_addx_8_mm_ay7 ", 0xf1ff, 0xd10f, { 18, 18, 12}},
{"m68k_op_add_8_re_pi7 ", 0xf1ff, 0xd11f, { 12, 12, 8}},
{"m68k_op_add_8_re_pd7 ", 0xf1ff, 0xd127, { 14, 14, 9}},
{"m68k_op_add_8_re_aw ", 0xf1ff, 0xd138, { 16, 16, 8}},
{"m68k_op_add_8_re_al ", 0xf1ff, 0xd139, { 20, 20, 8}},
{"m68k_op_add_16_re_aw ", 0xf1ff, 0xd178, { 16, 16, 8}},
{"m68k_op_add_16_re_al ", 0xf1ff, 0xd179, { 20, 20, 8}},
{"m68k_op_add_32_re_aw ", 0xf1ff, 0xd1b8, { 24, 24, 8}},
{"m68k_op_add_32_re_al ", 0xf1ff, 0xd1b9, { 28, 28, 8}},
{"m68k_op_adda_32_aw ", 0xf1ff, 0xd1f8, { 18, 18, 6}},
{"m68k_op_adda_32_al ", 0xf1ff, 0xd1f9, { 22, 22, 6}},
{"m68k_op_adda_32_pcdi ", 0xf1ff, 0xd1fa, { 18, 18, 7}},
{"m68k_op_adda_32_pcix ", 0xf1ff, 0xd1fb, { 20, 20, 9}},
{"m68k_op_adda_32_i ", 0xf1ff, 0xd1fc, { 16, 14, 6}},
{"m68k_op_ori_8_d ", 0xfff8, 0x0000, { 8, 8, 2}},
{"m68k_op_ori_8_ai ", 0xfff8, 0x0010, { 16, 16, 8}},
{"m68k_op_ori_8_pi ", 0xfff8, 0x0018, { 16, 16, 8}},
{"m68k_op_ori_8_pd ", 0xfff8, 0x0020, { 18, 18, 9}},
{"m68k_op_ori_8_di ", 0xfff8, 0x0028, { 20, 20, 9}},
{"m68k_op_ori_8_ix ", 0xfff8, 0x0030, { 22, 22, 11}},
{"m68k_op_ori_16_d ", 0xfff8, 0x0040, { 8, 8, 2}},
{"m68k_op_ori_16_ai ", 0xfff8, 0x0050, { 16, 16, 8}},
{"m68k_op_ori_16_pi ", 0xfff8, 0x0058, { 16, 16, 8}},
{"m68k_op_ori_16_pd ", 0xfff8, 0x0060, { 18, 18, 9}},
{"m68k_op_ori_16_di ", 0xfff8, 0x0068, { 20, 20, 9}},
{"m68k_op_ori_16_ix ", 0xfff8, 0x0070, { 22, 22, 11}},
{"m68k_op_ori_32_d ", 0xfff8, 0x0080, { 16, 14, 2}},
{"m68k_op_ori_32_ai ", 0xfff8, 0x0090, { 28, 28, 8}},
{"m68k_op_ori_32_pi ", 0xfff8, 0x0098, { 28, 28, 8}},
{"m68k_op_ori_32_pd ", 0xfff8, 0x00a0, { 30, 30, 9}},
{"m68k_op_ori_32_di ", 0xfff8, 0x00a8, { 32, 32, 9}},
{"m68k_op_ori_32_ix ", 0xfff8, 0x00b0, { 34, 34, 11}},
{"m68k_op_chk2cmp2_8_ai ", 0xfff8, 0x00d0, { 0, 0, 22}},
{"m68k_op_chk2cmp2_8_di ", 0xfff8, 0x00e8, { 0, 0, 23}},
{"m68k_op_chk2cmp2_8_ix ", 0xfff8, 0x00f0, { 0, 0, 25}},
{"m68k_op_andi_8_d ", 0xfff8, 0x0200, { 8, 8, 2}},
{"m68k_op_andi_8_ai ", 0xfff8, 0x0210, { 16, 16, 8}},
{"m68k_op_andi_8_pi ", 0xfff8, 0x0218, { 16, 16, 8}},
{"m68k_op_andi_8_pd ", 0xfff8, 0x0220, { 18, 18, 9}},
{"m68k_op_andi_8_di ", 0xfff8, 0x0228, { 20, 20, 9}},
{"m68k_op_andi_8_ix ", 0xfff8, 0x0230, { 22, 22, 11}},
{"m68k_op_andi_16_d ", 0xfff8, 0x0240, { 8, 8, 2}},
{"m68k_op_andi_16_ai ", 0xfff8, 0x0250, { 16, 16, 8}},
{"m68k_op_andi_16_pi ", 0xfff8, 0x0258, { 16, 16, 8}},
{"m68k_op_andi_16_pd ", 0xfff8, 0x0260, { 18, 18, 9}},
{"m68k_op_andi_16_di ", 0xfff8, 0x0268, { 20, 20, 9}},
{"m68k_op_andi_16_ix ", 0xfff8, 0x0270, { 22, 22, 11}},
{"m68k_op_andi_32_d ", 0xfff8, 0x0280, { 14, 14, 2}},
{"m68k_op_andi_32_ai ", 0xfff8, 0x0290, { 28, 28, 8}},
{"m68k_op_andi_32_pi ", 0xfff8, 0x0298, { 28, 28, 8}},
{"m68k_op_andi_32_pd ", 0xfff8, 0x02a0, { 30, 30, 9}},
{"m68k_op_andi_32_di ", 0xfff8, 0x02a8, { 32, 32, 9}},
{"m68k_op_andi_32_ix ", 0xfff8, 0x02b0, { 34, 34, 11}},
{"m68k_op_chk2cmp2_16_ai ", 0xfff8, 0x02d0, { 0, 0, 22}},
{"m68k_op_chk2cmp2_16_di ", 0xfff8, 0x02e8, { 0, 0, 23}},
{"m68k_op_chk2cmp2_16_ix ", 0xfff8, 0x02f0, { 0, 0, 25}},
{"m68k_op_subi_8_d ", 0xfff8, 0x0400, { 8, 8, 2}},
{"m68k_op_subi_8_ai ", 0xfff8, 0x0410, { 16, 16, 8}},
{"m68k_op_subi_8_pi ", 0xfff8, 0x0418, { 16, 16, 8}},
{"m68k_op_subi_8_pd ", 0xfff8, 0x0420, { 18, 18, 9}},
{"m68k_op_subi_8_di ", 0xfff8, 0x0428, { 20, 20, 9}},
{"m68k_op_subi_8_ix ", 0xfff8, 0x0430, { 22, 22, 11}},
{"m68k_op_subi_16_d ", 0xfff8, 0x0440, { 8, 8, 2}},
{"m68k_op_subi_16_ai ", 0xfff8, 0x0450, { 16, 16, 8}},
{"m68k_op_subi_16_pi ", 0xfff8, 0x0458, { 16, 16, 8}},
{"m68k_op_subi_16_pd ", 0xfff8, 0x0460, { 18, 18, 9}},
{"m68k_op_subi_16_di ", 0xfff8, 0x0468, { 20, 20, 9}},
{"m68k_op_subi_16_ix ", 0xfff8, 0x0470, { 22, 22, 11}},
{"m68k_op_subi_32_d ", 0xfff8, 0x0480, { 16, 14, 2}},
{"m68k_op_subi_32_ai ", 0xfff8, 0x0490, { 28, 28, 8}},
{"m68k_op_subi_32_pi ", 0xfff8, 0x0498, { 28, 28, 8}},
{"m68k_op_subi_32_pd ", 0xfff8, 0x04a0, { 30, 30, 9}},
{"m68k_op_subi_32_di ", 0xfff8, 0x04a8, { 32, 32, 9}},
{"m68k_op_subi_32_ix ", 0xfff8, 0x04b0, { 34, 34, 11}},
{"m68k_op_chk2cmp2_32_ai ", 0xfff8, 0x04d0, { 0, 0, 22}},
{"m68k_op_chk2cmp2_32_di ", 0xfff8, 0x04e8, { 0, 0, 23}},
{"m68k_op_chk2cmp2_32_ix ", 0xfff8, 0x04f0, { 0, 0, 25}},
{"m68k_op_addi_8_d ", 0xfff8, 0x0600, { 8, 8, 2}},
{"m68k_op_addi_8_ai ", 0xfff8, 0x0610, { 16, 16, 8}},
{"m68k_op_addi_8_pi ", 0xfff8, 0x0618, { 16, 16, 8}},
{"m68k_op_addi_8_pd ", 0xfff8, 0x0620, { 18, 18, 9}},
{"m68k_op_addi_8_di ", 0xfff8, 0x0628, { 20, 20, 9}},
{"m68k_op_addi_8_ix ", 0xfff8, 0x0630, { 22, 22, 11}},
{"m68k_op_addi_16_d ", 0xfff8, 0x0640, { 8, 8, 2}},
{"m68k_op_addi_16_ai ", 0xfff8, 0x0650, { 16, 16, 8}},
{"m68k_op_addi_16_pi ", 0xfff8, 0x0658, { 16, 16, 8}},
{"m68k_op_addi_16_pd ", 0xfff8, 0x0660, { 18, 18, 9}},
{"m68k_op_addi_16_di ", 0xfff8, 0x0668, { 20, 20, 9}},
{"m68k_op_addi_16_ix ", 0xfff8, 0x0670, { 22, 22, 11}},
{"m68k_op_addi_32_d ", 0xfff8, 0x0680, { 16, 14, 2}},
{"m68k_op_addi_32_ai ", 0xfff8, 0x0690, { 28, 28, 8}},
{"m68k_op_addi_32_pi ", 0xfff8, 0x0698, { 28, 28, 8}},
{"m68k_op_addi_32_pd ", 0xfff8, 0x06a0, { 30, 30, 9}},
{"m68k_op_addi_32_di ", 0xfff8, 0x06a8, { 32, 32, 9}},
{"m68k_op_addi_32_ix ", 0xfff8, 0x06b0, { 34, 34, 11}},
{"m68k_op_callm_32_ai ", 0xfff8, 0x06d0, { 0, 0, 64}},
{"m68k_op_callm_32_di ", 0xfff8, 0x06e8, { 0, 0, 65}},
{"m68k_op_callm_32_ix ", 0xfff8, 0x06f0, { 0, 0, 67}},
{"m68k_op_btst_32_s_d ", 0xfff8, 0x0800, { 10, 10, 4}},
{"m68k_op_btst_8_s_ai ", 0xfff8, 0x0810, { 12, 12, 8}},
{"m68k_op_btst_8_s_pi ", 0xfff8, 0x0818, { 12, 12, 8}},
{"m68k_op_btst_8_s_pd ", 0xfff8, 0x0820, { 14, 14, 9}},
{"m68k_op_btst_8_s_di ", 0xfff8, 0x0828, { 16, 16, 9}},
{"m68k_op_btst_8_s_ix ", 0xfff8, 0x0830, { 18, 18, 11}},
{"m68k_op_bchg_32_s_d ", 0xfff8, 0x0840, { 12, 12, 4}},
{"m68k_op_bchg_8_s_ai ", 0xfff8, 0x0850, { 16, 16, 8}},
{"m68k_op_bchg_8_s_pi ", 0xfff8, 0x0858, { 16, 16, 8}},
{"m68k_op_bchg_8_s_pd ", 0xfff8, 0x0860, { 18, 18, 9}},
{"m68k_op_bchg_8_s_di ", 0xfff8, 0x0868, { 20, 20, 9}},
{"m68k_op_bchg_8_s_ix ", 0xfff8, 0x0870, { 22, 22, 11}},
{"m68k_op_bclr_32_s_d ", 0xfff8, 0x0880, { 14, 14, 4}},
{"m68k_op_bclr_8_s_ai ", 0xfff8, 0x0890, { 16, 16, 8}},
{"m68k_op_bclr_8_s_pi ", 0xfff8, 0x0898, { 16, 16, 8}},
{"m68k_op_bclr_8_s_pd ", 0xfff8, 0x08a0, { 18, 18, 9}},
{"m68k_op_bclr_8_s_di ", 0xfff8, 0x08a8, { 20, 20, 9}},
{"m68k_op_bclr_8_s_ix ", 0xfff8, 0x08b0, { 22, 22, 11}},
{"m68k_op_bset_32_s_d ", 0xfff8, 0x08c0, { 12, 12, 4}},
{"m68k_op_bset_8_s_ai ", 0xfff8, 0x08d0, { 16, 16, 8}},
{"m68k_op_bset_8_s_pi ", 0xfff8, 0x08d8, { 16, 16, 8}},
{"m68k_op_bset_8_s_pd ", 0xfff8, 0x08e0, { 18, 18, 9}},
{"m68k_op_bset_8_s_di ", 0xfff8, 0x08e8, { 20, 20, 9}},
{"m68k_op_bset_8_s_ix ", 0xfff8, 0x08f0, { 22, 22, 11}},
{"m68k_op_eori_8_d ", 0xfff8, 0x0a00, { 8, 8, 2}},
{"m68k_op_eori_8_ai ", 0xfff8, 0x0a10, { 16, 16, 8}},
{"m68k_op_eori_8_pi ", 0xfff8, 0x0a18, { 16, 16, 8}},
{"m68k_op_eori_8_pd ", 0xfff8, 0x0a20, { 18, 18, 9}},
{"m68k_op_eori_8_di ", 0xfff8, 0x0a28, { 20, 20, 9}},
{"m68k_op_eori_8_ix ", 0xfff8, 0x0a30, { 22, 22, 11}},
{"m68k_op_eori_16_d ", 0xfff8, 0x0a40, { 8, 8, 2}},
{"m68k_op_eori_16_ai ", 0xfff8, 0x0a50, { 16, 16, 8}},
{"m68k_op_eori_16_pi ", 0xfff8, 0x0a58, { 16, 16, 8}},
{"m68k_op_eori_16_pd ", 0xfff8, 0x0a60, { 18, 18, 9}},
{"m68k_op_eori_16_di ", 0xfff8, 0x0a68, { 20, 20, 9}},
{"m68k_op_eori_16_ix ", 0xfff8, 0x0a70, { 22, 22, 11}},
{"m68k_op_eori_32_d ", 0xfff8, 0x0a80, { 16, 14, 2}},
{"m68k_op_eori_32_ai ", 0xfff8, 0x0a90, { 28, 28, 8}},
{"m68k_op_eori_32_pi ", 0xfff8, 0x0a98, { 28, 28, 8}},
{"m68k_op_eori_32_pd ", 0xfff8, 0x0aa0, { 30, 30, 9}},
{"m68k_op_eori_32_di ", 0xfff8, 0x0aa8, { 32, 32, 9}},
{"m68k_op_eori_32_ix ", 0xfff8, 0x0ab0, { 34, 34, 11}},
{"m68k_op_cas_8_ai ", 0xfff8, 0x0ad0, { 0, 0, 16}},
{"m68k_op_cas_8_pi ", 0xfff8, 0x0ad8, { 0, 0, 16}},
{"m68k_op_cas_8_pd ", 0xfff8, 0x0ae0, { 0, 0, 17}},
{"m68k_op_cas_8_di ", 0xfff8, 0x0ae8, { 0, 0, 17}},
{"m68k_op_cas_8_ix ", 0xfff8, 0x0af0, { 0, 0, 19}},
{"m68k_op_cmpi_8_d ", 0xfff8, 0x0c00, { 8, 8, 2}},
{"m68k_op_cmpi_8_ai ", 0xfff8, 0x0c10, { 12, 12, 6}},
{"m68k_op_cmpi_8_pi ", 0xfff8, 0x0c18, { 12, 12, 6}},
{"m68k_op_cmpi_8_pd ", 0xfff8, 0x0c20, { 14, 14, 7}},
{"m68k_op_cmpi_8_di ", 0xfff8, 0x0c28, { 16, 16, 7}},
{"m68k_op_cmpi_8_ix ", 0xfff8, 0x0c30, { 18, 18, 9}},
{"m68k_op_cmpi_16_d ", 0xfff8, 0x0c40, { 8, 8, 2}},
{"m68k_op_cmpi_16_ai ", 0xfff8, 0x0c50, { 12, 12, 6}},
{"m68k_op_cmpi_16_pi ", 0xfff8, 0x0c58, { 12, 12, 6}},
{"m68k_op_cmpi_16_pd ", 0xfff8, 0x0c60, { 14, 14, 7}},
{"m68k_op_cmpi_16_di ", 0xfff8, 0x0c68, { 16, 16, 7}},
{"m68k_op_cmpi_16_ix ", 0xfff8, 0x0c70, { 18, 18, 9}},
{"m68k_op_cmpi_32_d ", 0xfff8, 0x0c80, { 14, 12, 2}},
{"m68k_op_cmpi_32_ai ", 0xfff8, 0x0c90, { 20, 20, 6}},
{"m68k_op_cmpi_32_pi ", 0xfff8, 0x0c98, { 20, 20, 6}},
{"m68k_op_cmpi_32_pd ", 0xfff8, 0x0ca0, { 22, 22, 7}},
{"m68k_op_cmpi_32_di ", 0xfff8, 0x0ca8, { 24, 24, 7}},
{"m68k_op_cmpi_32_ix ", 0xfff8, 0x0cb0, { 26, 26, 9}},
{"m68k_op_cas_16_ai ", 0xfff8, 0x0cd0, { 0, 0, 16}},
{"m68k_op_cas_16_pi ", 0xfff8, 0x0cd8, { 0, 0, 16}},
{"m68k_op_cas_16_pd ", 0xfff8, 0x0ce0, { 0, 0, 17}},
{"m68k_op_cas_16_di ", 0xfff8, 0x0ce8, { 0, 0, 17}},
{"m68k_op_cas_16_ix ", 0xfff8, 0x0cf0, { 0, 0, 19}},
{"m68k_op_moves_8_ai ", 0xfff8, 0x0e10, { 0, 18, 9}},
{"m68k_op_moves_8_pi ", 0xfff8, 0x0e18, { 0, 18, 9}},
{"m68k_op_moves_8_pd ", 0xfff8, 0x0e20, { 0, 20, 10}},
{"m68k_op_moves_8_di ", 0xfff8, 0x0e28, { 0, 26, 10}},
{"m68k_op_moves_8_ix ", 0xfff8, 0x0e30, { 0, 30, 12}},
{"m68k_op_moves_16_ai ", 0xfff8, 0x0e50, { 0, 18, 9}},
{"m68k_op_moves_16_pi ", 0xfff8, 0x0e58, { 0, 18, 9}},
{"m68k_op_moves_16_pd ", 0xfff8, 0x0e60, { 0, 20, 10}},
{"m68k_op_moves_16_di ", 0xfff8, 0x0e68, { 0, 26, 10}},
{"m68k_op_moves_16_ix ", 0xfff8, 0x0e70, { 0, 30, 12}},
{"m68k_op_moves_32_ai ", 0xfff8, 0x0e90, { 0, 22, 9}},
{"m68k_op_moves_32_pi ", 0xfff8, 0x0e98, { 0, 22, 9}},
{"m68k_op_moves_32_pd ", 0xfff8, 0x0ea0, { 0, 28, 10}},
{"m68k_op_moves_32_di ", 0xfff8, 0x0ea8, { 0, 32, 10}},
{"m68k_op_moves_32_ix ", 0xfff8, 0x0eb0, { 0, 36, 12}},
{"m68k_op_cas_32_ai ", 0xfff8, 0x0ed0, { 0, 0, 16}},
{"m68k_op_cas_32_pi ", 0xfff8, 0x0ed8, { 0, 0, 16}},
{"m68k_op_cas_32_pd ", 0xfff8, 0x0ee0, { 0, 0, 17}},
{"m68k_op_cas_32_di ", 0xfff8, 0x0ee8, { 0, 0, 17}},
{"m68k_op_cas_32_ix ", 0xfff8, 0x0ef0, { 0, 0, 19}},
{"m68k_op_move_8_aw_d ", 0xfff8, 0x11c0, { 12, 12, 4}},
{"m68k_op_move_8_aw_ai ", 0xfff8, 0x11d0, { 16, 16, 8}},
{"m68k_op_move_8_aw_pi ", 0xfff8, 0x11d8, { 16, 16, 8}},
{"m68k_op_move_8_aw_pd ", 0xfff8, 0x11e0, { 18, 18, 9}},
{"m68k_op_move_8_aw_di ", 0xfff8, 0x11e8, { 20, 20, 9}},
{"m68k_op_move_8_aw_ix ", 0xfff8, 0x11f0, { 22, 22, 11}},
{"m68k_op_move_8_al_d ", 0xfff8, 0x13c0, { 16, 16, 6}},
{"m68k_op_move_8_al_ai ", 0xfff8, 0x13d0, { 20, 20, 10}},
{"m68k_op_move_8_al_pi ", 0xfff8, 0x13d8, { 20, 20, 10}},
{"m68k_op_move_8_al_pd ", 0xfff8, 0x13e0, { 22, 22, 11}},
{"m68k_op_move_8_al_di ", 0xfff8, 0x13e8, { 24, 24, 11}},
{"m68k_op_move_8_al_ix ", 0xfff8, 0x13f0, { 26, 26, 13}},
{"m68k_op_move_8_pi7_d ", 0xfff8, 0x1ec0, { 8, 8, 4}},
{"m68k_op_move_8_pi7_ai ", 0xfff8, 0x1ed0, { 12, 12, 8}},
{"m68k_op_move_8_pi7_pi ", 0xfff8, 0x1ed8, { 12, 12, 8}},
{"m68k_op_move_8_pi7_pd ", 0xfff8, 0x1ee0, { 14, 14, 9}},
{"m68k_op_move_8_pi7_di ", 0xfff8, 0x1ee8, { 16, 16, 9}},
{"m68k_op_move_8_pi7_ix ", 0xfff8, 0x1ef0, { 18, 18, 11}},
{"m68k_op_move_8_pd7_d ", 0xfff8, 0x1f00, { 8, 8, 5}},
{"m68k_op_move_8_pd7_ai ", 0xfff8, 0x1f10, { 12, 12, 9}},
{"m68k_op_move_8_pd7_pi ", 0xfff8, 0x1f18, { 12, 12, 9}},
{"m68k_op_move_8_pd7_pd ", 0xfff8, 0x1f20, { 14, 14, 10}},
{"m68k_op_move_8_pd7_di ", 0xfff8, 0x1f28, { 16, 16, 10}},
{"m68k_op_move_8_pd7_ix ", 0xfff8, 0x1f30, { 18, 18, 12}},
{"m68k_op_move_32_aw_d ", 0xfff8, 0x21c0, { 16, 16, 4}},
{"m68k_op_move_32_aw_a ", 0xfff8, 0x21c8, { 16, 16, 4}},
{"m68k_op_move_32_aw_ai ", 0xfff8, 0x21d0, { 24, 24, 8}},
{"m68k_op_move_32_aw_pi ", 0xfff8, 0x21d8, { 24, 24, 8}},
{"m68k_op_move_32_aw_pd ", 0xfff8, 0x21e0, { 26, 26, 9}},
{"m68k_op_move_32_aw_di ", 0xfff8, 0x21e8, { 28, 28, 9}},
{"m68k_op_move_32_aw_ix ", 0xfff8, 0x21f0, { 30, 30, 11}},
{"m68k_op_move_32_al_d ", 0xfff8, 0x23c0, { 20, 20, 6}},
{"m68k_op_move_32_al_a ", 0xfff8, 0x23c8, { 20, 20, 6}},
{"m68k_op_move_32_al_ai ", 0xfff8, 0x23d0, { 28, 28, 10}},
{"m68k_op_move_32_al_pi ", 0xfff8, 0x23d8, { 28, 28, 10}},
{"m68k_op_move_32_al_pd ", 0xfff8, 0x23e0, { 30, 30, 11}},
{"m68k_op_move_32_al_di ", 0xfff8, 0x23e8, { 32, 32, 11}},
{"m68k_op_move_32_al_ix ", 0xfff8, 0x23f0, { 34, 34, 13}},
{"m68k_op_move_16_aw_d ", 0xfff8, 0x31c0, { 12, 12, 4}},
{"m68k_op_move_16_aw_a ", 0xfff8, 0x31c8, { 12, 12, 4}},
{"m68k_op_move_16_aw_ai ", 0xfff8, 0x31d0, { 16, 16, 8}},
{"m68k_op_move_16_aw_pi ", 0xfff8, 0x31d8, { 16, 16, 8}},
{"m68k_op_move_16_aw_pd ", 0xfff8, 0x31e0, { 18, 18, 9}},
{"m68k_op_move_16_aw_di ", 0xfff8, 0x31e8, { 20, 20, 9}},
{"m68k_op_move_16_aw_ix ", 0xfff8, 0x31f0, { 22, 22, 11}},
{"m68k_op_move_16_al_d ", 0xfff8, 0x33c0, { 16, 16, 6}},
{"m68k_op_move_16_al_a ", 0xfff8, 0x33c8, { 16, 16, 6}},
{"m68k_op_move_16_al_ai ", 0xfff8, 0x33d0, { 20, 20, 10}},
{"m68k_op_move_16_al_pi ", 0xfff8, 0x33d8, { 20, 20, 10}},
{"m68k_op_move_16_al_pd ", 0xfff8, 0x33e0, { 22, 22, 11}},
{"m68k_op_move_16_al_di ", 0xfff8, 0x33e8, { 24, 24, 11}},
{"m68k_op_move_16_al_ix ", 0xfff8, 0x33f0, { 26, 26, 13}},
{"m68k_op_negx_8_d ", 0xfff8, 0x4000, { 4, 4, 2}},
{"m68k_op_negx_8_ai ", 0xfff8, 0x4010, { 12, 12, 8}},
{"m68k_op_negx_8_pi ", 0xfff8, 0x4018, { 12, 12, 8}},
{"m68k_op_negx_8_pd ", 0xfff8, 0x4020, { 14, 14, 9}},
{"m68k_op_negx_8_di ", 0xfff8, 0x4028, { 16, 16, 9}},
{"m68k_op_negx_8_ix ", 0xfff8, 0x4030, { 18, 18, 11}},
{"m68k_op_negx_16_d ", 0xfff8, 0x4040, { 4, 4, 2}},
{"m68k_op_negx_16_ai ", 0xfff8, 0x4050, { 12, 12, 8}},
{"m68k_op_negx_16_pi ", 0xfff8, 0x4058, { 12, 12, 8}},
{"m68k_op_negx_16_pd ", 0xfff8, 0x4060, { 14, 14, 9}},
{"m68k_op_negx_16_di ", 0xfff8, 0x4068, { 16, 16, 9}},
{"m68k_op_negx_16_ix ", 0xfff8, 0x4070, { 18, 18, 11}},
{"m68k_op_negx_32_d ", 0xfff8, 0x4080, { 6, 6, 2}},
{"m68k_op_negx_32_ai ", 0xfff8, 0x4090, { 20, 20, 8}},
{"m68k_op_negx_32_pi ", 0xfff8, 0x4098, { 20, 20, 8}},
{"m68k_op_negx_32_pd ", 0xfff8, 0x40a0, { 22, 22, 9}},
{"m68k_op_negx_32_di ", 0xfff8, 0x40a8, { 24, 24, 9}},
{"m68k_op_negx_32_ix ", 0xfff8, 0x40b0, { 26, 26, 11}},
{"m68k_op_move_16_frs_d ", 0xfff8, 0x40c0, { 6, 4, 8}},
{"m68k_op_move_16_frs_ai ", 0xfff8, 0x40d0, { 12, 12, 12}},
{"m68k_op_move_16_frs_pi ", 0xfff8, 0x40d8, { 12, 12, 12}},
{"m68k_op_move_16_frs_pd ", 0xfff8, 0x40e0, { 14, 14, 13}},
{"m68k_op_move_16_frs_di ", 0xfff8, 0x40e8, { 16, 16, 13}},
{"m68k_op_move_16_frs_ix ", 0xfff8, 0x40f0, { 18, 18, 15}},
{"m68k_op_clr_8_d ", 0xfff8, 0x4200, { 4, 4, 2}},
{"m68k_op_clr_8_ai ", 0xfff8, 0x4210, { 12, 8, 8}},
{"m68k_op_clr_8_pi ", 0xfff8, 0x4218, { 12, 8, 8}},
{"m68k_op_clr_8_pd ", 0xfff8, 0x4220, { 14, 10, 9}},
{"m68k_op_clr_8_di ", 0xfff8, 0x4228, { 16, 12, 9}},
{"m68k_op_clr_8_ix ", 0xfff8, 0x4230, { 18, 14, 11}},
{"m68k_op_clr_16_d ", 0xfff8, 0x4240, { 4, 4, 2}},
{"m68k_op_clr_16_ai ", 0xfff8, 0x4250, { 12, 8, 8}},
{"m68k_op_clr_16_pi ", 0xfff8, 0x4258, { 12, 8, 8}},
{"m68k_op_clr_16_pd ", 0xfff8, 0x4260, { 14, 10, 9}},
{"m68k_op_clr_16_di ", 0xfff8, 0x4268, { 16, 12, 9}},
{"m68k_op_clr_16_ix ", 0xfff8, 0x4270, { 18, 14, 11}},
{"m68k_op_clr_32_d ", 0xfff8, 0x4280, { 6, 6, 2}},
{"m68k_op_clr_32_ai ", 0xfff8, 0x4290, { 20, 12, 8}},
{"m68k_op_clr_32_pi ", 0xfff8, 0x4298, { 20, 12, 8}},
{"m68k_op_clr_32_pd ", 0xfff8, 0x42a0, { 22, 14, 9}},
{"m68k_op_clr_32_di ", 0xfff8, 0x42a8, { 24, 16, 9}},
{"m68k_op_clr_32_ix ", 0xfff8, 0x42b0, { 26, 20, 11}},
{"m68k_op_move_16_frc_d ", 0xfff8, 0x42c0, { 0, 4, 4}},
{"m68k_op_move_16_frc_ai ", 0xfff8, 0x42d0, { 0, 12, 8}},
{"m68k_op_move_16_frc_pi ", 0xfff8, 0x42d8, { 0, 12, 8}},
{"m68k_op_move_16_frc_pd ", 0xfff8, 0x42e0, { 0, 14, 9}},
{"m68k_op_move_16_frc_di ", 0xfff8, 0x42e8, { 0, 16, 9}},
{"m68k_op_move_16_frc_ix ", 0xfff8, 0x42f0, { 0, 18, 11}},
{"m68k_op_neg_8_d ", 0xfff8, 0x4400, { 4, 4, 2}},
{"m68k_op_neg_8_ai ", 0xfff8, 0x4410, { 12, 12, 8}},
{"m68k_op_neg_8_pi ", 0xfff8, 0x4418, { 12, 12, 8}},
{"m68k_op_neg_8_pd ", 0xfff8, 0x4420, { 14, 14, 9}},
{"m68k_op_neg_8_di ", 0xfff8, 0x4428, { 16, 16, 9}},
{"m68k_op_neg_8_ix ", 0xfff8, 0x4430, { 18, 18, 11}},
{"m68k_op_neg_16_d ", 0xfff8, 0x4440, { 4, 4, 2}},
{"m68k_op_neg_16_ai ", 0xfff8, 0x4450, { 12, 12, 8}},
{"m68k_op_neg_16_pi ", 0xfff8, 0x4458, { 12, 12, 8}},
{"m68k_op_neg_16_pd ", 0xfff8, 0x4460, { 14, 14, 9}},
{"m68k_op_neg_16_di ", 0xfff8, 0x4468, { 16, 16, 9}},
{"m68k_op_neg_16_ix ", 0xfff8, 0x4470, { 18, 18, 11}},
{"m68k_op_neg_32_d ", 0xfff8, 0x4480, { 6, 6, 2}},
{"m68k_op_neg_32_ai ", 0xfff8, 0x4490, { 20, 20, 8}},
{"m68k_op_neg_32_pi ", 0xfff8, 0x4498, { 20, 20, 8}},
{"m68k_op_neg_32_pd ", 0xfff8, 0x44a0, { 22, 22, 9}},
{"m68k_op_neg_32_di ", 0xfff8, 0x44a8, { 24, 24, 9}},
{"m68k_op_neg_32_ix ", 0xfff8, 0x44b0, { 26, 26, 11}},
{"m68k_op_move_16_toc_d ", 0xfff8, 0x44c0, { 12, 12, 4}},
{"m68k_op_move_16_toc_ai ", 0xfff8, 0x44d0, { 16, 16, 8}},
{"m68k_op_move_16_toc_pi ", 0xfff8, 0x44d8, { 16, 16, 8}},
{"m68k_op_move_16_toc_pd ", 0xfff8, 0x44e0, { 18, 18, 9}},
{"m68k_op_move_16_toc_di ", 0xfff8, 0x44e8, { 20, 20, 9}},
{"m68k_op_move_16_toc_ix ", 0xfff8, 0x44f0, { 22, 22, 11}},
{"m68k_op_not_8_d ", 0xfff8, 0x4600, { 4, 4, 2}},
{"m68k_op_not_8_ai ", 0xfff8, 0x4610, { 12, 12, 8}},
{"m68k_op_not_8_pi ", 0xfff8, 0x4618, { 12, 12, 8}},
{"m68k_op_not_8_pd ", 0xfff8, 0x4620, { 14, 14, 9}},
{"m68k_op_not_8_di ", 0xfff8, 0x4628, { 16, 16, 9}},
{"m68k_op_not_8_ix ", 0xfff8, 0x4630, { 18, 18, 11}},
{"m68k_op_not_16_d ", 0xfff8, 0x4640, { 4, 4, 2}},
{"m68k_op_not_16_ai ", 0xfff8, 0x4650, { 12, 12, 8}},
{"m68k_op_not_16_pi ", 0xfff8, 0x4658, { 12, 12, 8}},
{"m68k_op_not_16_pd ", 0xfff8, 0x4660, { 14, 14, 9}},
{"m68k_op_not_16_di ", 0xfff8, 0x4668, { 16, 16, 9}},
{"m68k_op_not_16_ix ", 0xfff8, 0x4670, { 18, 18, 11}},
{"m68k_op_not_32_d ", 0xfff8, 0x4680, { 6, 6, 2}},
{"m68k_op_not_32_ai ", 0xfff8, 0x4690, { 20, 20, 8}},
{"m68k_op_not_32_pi ", 0xfff8, 0x4698, { 20, 20, 8}},
{"m68k_op_not_32_pd ", 0xfff8, 0x46a0, { 22, 22, 9}},
{"m68k_op_not_32_di ", 0xfff8, 0x46a8, { 24, 24, 9}},
{"m68k_op_not_32_ix ", 0xfff8, 0x46b0, { 26, 26, 11}},
{"m68k_op_move_16_tos_d ", 0xfff8, 0x46c0, { 12, 12, 8}},
{"m68k_op_move_16_tos_ai ", 0xfff8, 0x46d0, { 16, 16, 12}},
{"m68k_op_move_16_tos_pi ", 0xfff8, 0x46d8, { 16, 16, 12}},
{"m68k_op_move_16_tos_pd ", 0xfff8, 0x46e0, { 18, 18, 13}},
{"m68k_op_move_16_tos_di ", 0xfff8, 0x46e8, { 20, 20, 13}},
{"m68k_op_move_16_tos_ix ", 0xfff8, 0x46f0, { 22, 22, 15}},
{"m68k_op_nbcd_8_d ", 0xfff8, 0x4800, { 6, 6, 6}},
{"m68k_op_link_32 ", 0xfff8, 0x4808, { 0, 0, 6}},
{"m68k_op_nbcd_8_ai ", 0xfff8, 0x4810, { 12, 12, 10}},
{"m68k_op_nbcd_8_pi ", 0xfff8, 0x4818, { 12, 12, 10}},
{"m68k_op_nbcd_8_pd ", 0xfff8, 0x4820, { 14, 14, 11}},
{"m68k_op_nbcd_8_di ", 0xfff8, 0x4828, { 16, 16, 11}},
{"m68k_op_nbcd_8_ix ", 0xfff8, 0x4830, { 18, 18, 13}},
{"m68k_op_swap_32 ", 0xfff8, 0x4840, { 4, 4, 4}},
{"m68k_op_bkpt ", 0xfff8, 0x4848, { 0, 10, 10}},
{"m68k_op_pea_32_ai ", 0xfff8, 0x4850, { 12, 12, 9}},
{"m68k_op_pea_32_di ", 0xfff8, 0x4868, { 16, 16, 10}},
{"m68k_op_pea_32_ix ", 0xfff8, 0x4870, { 20, 20, 12}},
{"m68k_op_ext_16 ", 0xfff8, 0x4880, { 4, 4, 4}},
{"m68k_op_movem_16_re_ai ", 0xfff8, 0x4890, { 8, 8, 8}},
{"m68k_op_movem_16_re_pd ", 0xfff8, 0x48a0, { 8, 8, 4}},
{"m68k_op_movem_16_re_di ", 0xfff8, 0x48a8, { 12, 12, 9}},
{"m68k_op_movem_16_re_ix ", 0xfff8, 0x48b0, { 14, 14, 11}},
{"m68k_op_ext_32 ", 0xfff8, 0x48c0, { 4, 4, 4}},
{"m68k_op_movem_32_re_ai ", 0xfff8, 0x48d0, { 8, 8, 8}},
{"m68k_op_movem_32_re_pd ", 0xfff8, 0x48e0, { 8, 8, 4}},
{"m68k_op_movem_32_re_di ", 0xfff8, 0x48e8, { 12, 12, 9}},
{"m68k_op_movem_32_re_ix ", 0xfff8, 0x48f0, { 14, 14, 11}},
{"m68k_op_extb_32 ", 0xfff8, 0x49c0, { 0, 0, 4}},
{"m68k_op_tst_8_d ", 0xfff8, 0x4a00, { 4, 4, 2}},
{"m68k_op_tst_8_ai ", 0xfff8, 0x4a10, { 8, 8, 6}},
{"m68k_op_tst_8_pi ", 0xfff8, 0x4a18, { 8, 8, 6}},
{"m68k_op_tst_8_pd ", 0xfff8, 0x4a20, { 10, 10, 7}},
{"m68k_op_tst_8_di ", 0xfff8, 0x4a28, { 12, 12, 7}},
{"m68k_op_tst_8_ix ", 0xfff8, 0x4a30, { 14, 14, 9}},
{"m68k_op_tst_16_d ", 0xfff8, 0x4a40, { 4, 4, 2}},
{"m68k_op_tst_16_a ", 0xfff8, 0x4a48, { 0, 0, 2}},
{"m68k_op_tst_16_ai ", 0xfff8, 0x4a50, { 8, 8, 6}},
{"m68k_op_tst_16_pi ", 0xfff8, 0x4a58, { 8, 8, 6}},
{"m68k_op_tst_16_pd ", 0xfff8, 0x4a60, { 10, 10, 7}},
{"m68k_op_tst_16_di ", 0xfff8, 0x4a68, { 12, 12, 7}},
{"m68k_op_tst_16_ix ", 0xfff8, 0x4a70, { 14, 14, 9}},
{"m68k_op_tst_32_d ", 0xfff8, 0x4a80, { 4, 4, 2}},
{"m68k_op_tst_32_a ", 0xfff8, 0x4a88, { 0, 0, 2}},
{"m68k_op_tst_32_ai ", 0xfff8, 0x4a90, { 12, 12, 6}},
{"m68k_op_tst_32_pi ", 0xfff8, 0x4a98, { 12, 12, 6}},
{"m68k_op_tst_32_pd ", 0xfff8, 0x4aa0, { 14, 14, 7}},
{"m68k_op_tst_32_di ", 0xfff8, 0x4aa8, { 16, 16, 7}},
{"m68k_op_tst_32_ix ", 0xfff8, 0x4ab0, { 18, 18, 9}},
{"m68k_op_tas_8_d ", 0xfff8, 0x4ac0, { 4, 4, 4}},
{"m68k_op_tas_8_ai ", 0xfff8, 0x4ad0, { 18, 18, 16}},
{"m68k_op_tas_8_pi ", 0xfff8, 0x4ad8, { 18, 18, 16}},
{"m68k_op_tas_8_pd ", 0xfff8, 0x4ae0, { 20, 20, 17}},
{"m68k_op_tas_8_di ", 0xfff8, 0x4ae8, { 22, 22, 17}},
{"m68k_op_tas_8_ix ", 0xfff8, 0x4af0, { 24, 24, 19}},
{"m68k_op_mull_32_d ", 0xfff8, 0x4c00, { 0, 0, 43}},
{"m68k_op_mull_32_ai ", 0xfff8, 0x4c10, { 0, 0, 47}},
{"m68k_op_mull_32_pi ", 0xfff8, 0x4c18, { 0, 0, 47}},
{"m68k_op_mull_32_pd ", 0xfff8, 0x4c20, { 0, 0, 48}},
{"m68k_op_mull_32_di ", 0xfff8, 0x4c28, { 0, 0, 48}},
{"m68k_op_mull_32_ix ", 0xfff8, 0x4c30, { 0, 0, 50}},
{"m68k_op_divl_32_d ", 0xfff8, 0x4c40, { 0, 0, 84}},
{"m68k_op_divl_32_ai ", 0xfff8, 0x4c50, { 0, 0, 88}},
{"m68k_op_divl_32_pi ", 0xfff8, 0x4c58, { 0, 0, 88}},
{"m68k_op_divl_32_pd ", 0xfff8, 0x4c60, { 0, 0, 89}},
{"m68k_op_divl_32_di ", 0xfff8, 0x4c68, { 0, 0, 89}},
{"m68k_op_divl_32_ix ", 0xfff8, 0x4c70, { 0, 0, 91}},
{"m68k_op_movem_16_er_ai ", 0xfff8, 0x4c90, { 12, 12, 12}},
{"m68k_op_movem_16_er_pi ", 0xfff8, 0x4c98, { 12, 12, 8}},
{"m68k_op_movem_16_er_di ", 0xfff8, 0x4ca8, { 16, 16, 13}},
{"m68k_op_movem_16_er_ix ", 0xfff8, 0x4cb0, { 18, 18, 15}},
{"m68k_op_movem_32_er_ai ", 0xfff8, 0x4cd0, { 12, 12, 12}},
{"m68k_op_movem_32_er_pi ", 0xfff8, 0x4cd8, { 12, 12, 8}},
{"m68k_op_movem_32_er_di ", 0xfff8, 0x4ce8, { 16, 16, 13}},
{"m68k_op_movem_32_er_ix ", 0xfff8, 0x4cf0, { 18, 18, 15}},
{"m68k_op_link_16 ", 0xfff8, 0x4e50, { 16, 16, 5}},
{"m68k_op_unlk_32 ", 0xfff8, 0x4e58, { 12, 12, 6}},
{"m68k_op_move_32_tou ", 0xfff8, 0x4e60, { 4, 6, 2}},
{"m68k_op_move_32_fru ", 0xfff8, 0x4e68, { 4, 6, 2}},
{"m68k_op_jsr_32_ai ", 0xfff8, 0x4e90, { 16, 16, 4}},
{"m68k_op_jsr_32_di ", 0xfff8, 0x4ea8, { 18, 18, 5}},
{"m68k_op_jsr_32_ix ", 0xfff8, 0x4eb0, { 22, 22, 7}},
{"m68k_op_jmp_32_ai ", 0xfff8, 0x4ed0, { 8, 8, 4}},
{"m68k_op_jmp_32_di ", 0xfff8, 0x4ee8, { 10, 10, 5}},
{"m68k_op_jmp_32_ix ", 0xfff8, 0x4ef0, { 14, 14, 7}},
{"m68k_op_st_8_d ", 0xfff8, 0x50c0, { 6, 4, 4}},
{"m68k_op_dbt_16 ", 0xfff8, 0x50c8, { 12, 12, 6}},
{"m68k_op_st_8_ai ", 0xfff8, 0x50d0, { 12, 12, 10}},
{"m68k_op_st_8_pi ", 0xfff8, 0x50d8, { 12, 12, 10}},
{"m68k_op_st_8_pd ", 0xfff8, 0x50e0, { 14, 14, 11}},
{"m68k_op_st_8_di ", 0xfff8, 0x50e8, { 16, 16, 11}},
{"m68k_op_st_8_ix ", 0xfff8, 0x50f0, { 18, 18, 13}},
{"m68k_op_sf_8_d ", 0xfff8, 0x51c0, { 4, 4, 4}},
{"m68k_op_dbf_16 ", 0xfff8, 0x51c8, { 12, 12, 6}},
{"m68k_op_sf_8_ai ", 0xfff8, 0x51d0, { 12, 12, 10}},
{"m68k_op_sf_8_pi ", 0xfff8, 0x51d8, { 12, 12, 10}},
{"m68k_op_sf_8_pd ", 0xfff8, 0x51e0, { 14, 14, 11}},
{"m68k_op_sf_8_di ", 0xfff8, 0x51e8, { 16, 16, 11}},
{"m68k_op_sf_8_ix ", 0xfff8, 0x51f0, { 18, 18, 13}},
{"m68k_op_shi_8_d ", 0xfff8, 0x52c0, { 4, 4, 4}},
{"m68k_op_dbhi_16 ", 0xfff8, 0x52c8, { 12, 12, 6}},
{"m68k_op_shi_8_ai ", 0xfff8, 0x52d0, { 12, 12, 10}},
{"m68k_op_shi_8_pi ", 0xfff8, 0x52d8, { 12, 12, 10}},
{"m68k_op_shi_8_pd ", 0xfff8, 0x52e0, { 14, 14, 11}},
{"m68k_op_shi_8_di ", 0xfff8, 0x52e8, { 16, 16, 11}},
{"m68k_op_shi_8_ix ", 0xfff8, 0x52f0, { 18, 18, 13}},
{"m68k_op_sls_8_d ", 0xfff8, 0x53c0, { 4, 4, 4}},
{"m68k_op_dbls_16 ", 0xfff8, 0x53c8, { 12, 12, 6}},
{"m68k_op_sls_8_ai ", 0xfff8, 0x53d0, { 12, 12, 10}},
{"m68k_op_sls_8_pi ", 0xfff8, 0x53d8, { 12, 12, 10}},
{"m68k_op_sls_8_pd ", 0xfff8, 0x53e0, { 14, 14, 11}},
{"m68k_op_sls_8_di ", 0xfff8, 0x53e8, { 16, 16, 11}},
{"m68k_op_sls_8_ix ", 0xfff8, 0x53f0, { 18, 18, 13}},
{"m68k_op_scc_8_d ", 0xfff8, 0x54c0, { 4, 4, 4}},
{"m68k_op_dbcc_16 ", 0xfff8, 0x54c8, { 12, 12, 6}},
{"m68k_op_scc_8_ai ", 0xfff8, 0x54d0, { 12, 12, 10}},
{"m68k_op_scc_8_pi ", 0xfff8, 0x54d8, { 12, 12, 10}},
{"m68k_op_scc_8_pd ", 0xfff8, 0x54e0, { 14, 14, 11}},
{"m68k_op_scc_8_di ", 0xfff8, 0x54e8, { 16, 16, 11}},
{"m68k_op_scc_8_ix ", 0xfff8, 0x54f0, { 18, 18, 13}},
{"m68k_op_scs_8_d ", 0xfff8, 0x55c0, { 4, 4, 4}},
{"m68k_op_dbcs_16 ", 0xfff8, 0x55c8, { 12, 12, 6}},
{"m68k_op_scs_8_ai ", 0xfff8, 0x55d0, { 12, 12, 10}},
{"m68k_op_scs_8_pi ", 0xfff8, 0x55d8, { 12, 12, 10}},
{"m68k_op_scs_8_pd ", 0xfff8, 0x55e0, { 14, 14, 11}},
{"m68k_op_scs_8_di ", 0xfff8, 0x55e8, { 16, 16, 11}},
{"m68k_op_scs_8_ix ", 0xfff8, 0x55f0, { 18, 18, 13}},
{"m68k_op_sne_8_d ", 0xfff8, 0x56c0, { 4, 4, 4}},
{"m68k_op_dbne_16 ", 0xfff8, 0x56c8, { 12, 12, 6}},
{"m68k_op_sne_8_ai ", 0xfff8, 0x56d0, { 12, 12, 10}},
{"m68k_op_sne_8_pi ", 0xfff8, 0x56d8, { 12, 12, 10}},
{"m68k_op_sne_8_pd ", 0xfff8, 0x56e0, { 14, 14, 11}},
{"m68k_op_sne_8_di ", 0xfff8, 0x56e8, { 16, 16, 11}},
{"m68k_op_sne_8_ix ", 0xfff8, 0x56f0, { 18, 18, 13}},
{"m68k_op_seq_8_d ", 0xfff8, 0x57c0, { 4, 4, 4}},
{"m68k_op_dbeq_16 ", 0xfff8, 0x57c8, { 12, 12, 6}},
{"m68k_op_seq_8_ai ", 0xfff8, 0x57d0, { 12, 12, 10}},
{"m68k_op_seq_8_pi ", 0xfff8, 0x57d8, { 12, 12, 10}},
{"m68k_op_seq_8_pd ", 0xfff8, 0x57e0, { 14, 14, 11}},
{"m68k_op_seq_8_di ", 0xfff8, 0x57e8, { 16, 16, 11}},
{"m68k_op_seq_8_ix ", 0xfff8, 0x57f0, { 18, 18, 13}},
{"m68k_op_svc_8_d ", 0xfff8, 0x58c0, { 4, 4, 4}},
{"m68k_op_dbvc_16 ", 0xfff8, 0x58c8, { 12, 12, 6}},
{"m68k_op_svc_8_ai ", 0xfff8, 0x58d0, { 12, 12, 10}},
{"m68k_op_svc_8_pi ", 0xfff8, 0x58d8, { 12, 12, 10}},
{"m68k_op_svc_8_pd ", 0xfff8, 0x58e0, { 14, 14, 11}},
{"m68k_op_svc_8_di ", 0xfff8, 0x58e8, { 16, 16, 11}},
{"m68k_op_svc_8_ix ", 0xfff8, 0x58f0, { 18, 18, 13}},
{"m68k_op_svs_8_d ", 0xfff8, 0x59c0, { 4, 4, 4}},
{"m68k_op_dbvs_16 ", 0xfff8, 0x59c8, { 12, 12, 6}},
{"m68k_op_svs_8_ai ", 0xfff8, 0x59d0, { 12, 12, 10}},
{"m68k_op_svs_8_pi ", 0xfff8, 0x59d8, { 12, 12, 10}},
{"m68k_op_svs_8_pd ", 0xfff8, 0x59e0, { 14, 14, 11}},
{"m68k_op_svs_8_di ", 0xfff8, 0x59e8, { 16, 16, 11}},
{"m68k_op_svs_8_ix ", 0xfff8, 0x59f0, { 18, 18, 13}},
{"m68k_op_spl_8_d ", 0xfff8, 0x5ac0, { 4, 4, 4}},
{"m68k_op_dbpl_16 ", 0xfff8, 0x5ac8, { 12, 12, 6}},
{"m68k_op_spl_8_ai ", 0xfff8, 0x5ad0, { 12, 12, 10}},
{"m68k_op_spl_8_pi ", 0xfff8, 0x5ad8, { 12, 12, 10}},
{"m68k_op_spl_8_pd ", 0xfff8, 0x5ae0, { 14, 14, 11}},
{"m68k_op_spl_8_di ", 0xfff8, 0x5ae8, { 16, 16, 11}},
{"m68k_op_spl_8_ix ", 0xfff8, 0x5af0, { 18, 18, 13}},
{"m68k_op_smi_8_d ", 0xfff8, 0x5bc0, { 4, 4, 4}},
{"m68k_op_dbmi_16 ", 0xfff8, 0x5bc8, { 12, 12, 6}},
{"m68k_op_smi_8_ai ", 0xfff8, 0x5bd0, { 12, 12, 10}},
{"m68k_op_smi_8_pi ", 0xfff8, 0x5bd8, { 12, 12, 10}},
{"m68k_op_smi_8_pd ", 0xfff8, 0x5be0, { 14, 14, 11}},
{"m68k_op_smi_8_di ", 0xfff8, 0x5be8, { 16, 16, 11}},
{"m68k_op_smi_8_ix ", 0xfff8, 0x5bf0, { 18, 18, 13}},
{"m68k_op_sge_8_d ", 0xfff8, 0x5cc0, { 4, 4, 4}},
{"m68k_op_dbge_16 ", 0xfff8, 0x5cc8, { 12, 12, 6}},
{"m68k_op_sge_8_ai ", 0xfff8, 0x5cd0, { 12, 12, 10}},
{"m68k_op_sge_8_pi ", 0xfff8, 0x5cd8, { 12, 12, 10}},
{"m68k_op_sge_8_pd ", 0xfff8, 0x5ce0, { 14, 14, 11}},
{"m68k_op_sge_8_di ", 0xfff8, 0x5ce8, { 16, 16, 11}},
{"m68k_op_sge_8_ix ", 0xfff8, 0x5cf0, { 18, 18, 13}},
{"m68k_op_slt_8_d ", 0xfff8, 0x5dc0, { 4, 4, 4}},
{"m68k_op_dblt_16 ", 0xfff8, 0x5dc8, { 12, 12, 6}},
{"m68k_op_slt_8_ai ", 0xfff8, 0x5dd0, { 12, 12, 10}},
{"m68k_op_slt_8_pi ", 0xfff8, 0x5dd8, { 12, 12, 10}},
{"m68k_op_slt_8_pd ", 0xfff8, 0x5de0, { 14, 14, 11}},
{"m68k_op_slt_8_di ", 0xfff8, 0x5de8, { 16, 16, 11}},
{"m68k_op_slt_8_ix ", 0xfff8, 0x5df0, { 18, 18, 13}},
{"m68k_op_sgt_8_d ", 0xfff8, 0x5ec0, { 4, 4, 4}},
{"m68k_op_dbgt_16 ", 0xfff8, 0x5ec8, { 12, 12, 6}},
{"m68k_op_sgt_8_ai ", 0xfff8, 0x5ed0, { 12, 12, 10}},
{"m68k_op_sgt_8_pi ", 0xfff8, 0x5ed8, { 12, 12, 10}},
{"m68k_op_sgt_8_pd ", 0xfff8, 0x5ee0, { 14, 14, 11}},
{"m68k_op_sgt_8_di ", 0xfff8, 0x5ee8, { 16, 16, 11}},
{"m68k_op_sgt_8_ix ", 0xfff8, 0x5ef0, { 18, 18, 13}},
{"m68k_op_sle_8_d ", 0xfff8, 0x5fc0, { 4, 4, 4}},
{"m68k_op_dble_16 ", 0xfff8, 0x5fc8, { 12, 12, 6}},
{"m68k_op_sle_8_ai ", 0xfff8, 0x5fd0, { 12, 12, 10}},
{"m68k_op_sle_8_pi ", 0xfff8, 0x5fd8, { 12, 12, 10}},
{"m68k_op_sle_8_pd ", 0xfff8, 0x5fe0, { 14, 14, 11}},
{"m68k_op_sle_8_di ", 0xfff8, 0x5fe8, { 16, 16, 11}},
{"m68k_op_sle_8_ix ", 0xfff8, 0x5ff0, { 18, 18, 13}},
{"m68k_op_sbcd_8_mm_ax7 ", 0xfff8, 0x8f08, { 18, 18, 16}},
{"m68k_op_pack_16_mm_ax7 ", 0xfff8, 0x8f48, { 0, 0, 13}},
{"m68k_op_unpk_16_mm_ax7 ", 0xfff8, 0x8f88, { 0, 0, 13}},
{"m68k_op_subx_8_mm_ax7 ", 0xfff8, 0x9f08, { 18, 18, 12}},
{"m68k_op_cmpm_8_ax7 ", 0xfff8, 0xbf08, { 12, 12, 9}},
{"m68k_op_abcd_8_mm_ax7 ", 0xfff8, 0xcf08, { 18, 18, 16}},
{"m68k_op_addx_8_mm_ax7 ", 0xfff8, 0xdf08, { 18, 18, 12}},
{"m68k_op_asr_16_ai ", 0xfff8, 0xe0d0, { 12, 12, 9}},
{"m68k_op_asr_16_pi ", 0xfff8, 0xe0d8, { 12, 12, 9}},
{"m68k_op_asr_16_pd ", 0xfff8, 0xe0e0, { 14, 14, 10}},
{"m68k_op_asr_16_di ", 0xfff8, 0xe0e8, { 16, 16, 10}},
{"m68k_op_asr_16_ix ", 0xfff8, 0xe0f0, { 18, 18, 12}},
{"m68k_op_asl_16_ai ", 0xfff8, 0xe1d0, { 12, 12, 10}},
{"m68k_op_asl_16_pi ", 0xfff8, 0xe1d8, { 12, 12, 10}},
{"m68k_op_asl_16_pd ", 0xfff8, 0xe1e0, { 14, 14, 11}},
{"m68k_op_asl_16_di ", 0xfff8, 0xe1e8, { 16, 16, 11}},
{"m68k_op_asl_16_ix ", 0xfff8, 0xe1f0, { 18, 18, 13}},
{"m68k_op_lsr_16_ai ", 0xfff8, 0xe2d0, { 12, 12, 9}},
{"m68k_op_lsr_16_pi ", 0xfff8, 0xe2d8, { 12, 12, 9}},
{"m68k_op_lsr_16_pd ", 0xfff8, 0xe2e0, { 14, 14, 10}},
{"m68k_op_lsr_16_di ", 0xfff8, 0xe2e8, { 16, 16, 10}},
{"m68k_op_lsr_16_ix ", 0xfff8, 0xe2f0, { 18, 18, 12}},
{"m68k_op_lsl_16_ai ", 0xfff8, 0xe3d0, { 12, 12, 9}},
{"m68k_op_lsl_16_pi ", 0xfff8, 0xe3d8, { 12, 12, 9}},
{"m68k_op_lsl_16_pd ", 0xfff8, 0xe3e0, { 14, 14, 10}},
{"m68k_op_lsl_16_di ", 0xfff8, 0xe3e8, { 16, 16, 10}},
{"m68k_op_lsl_16_ix ", 0xfff8, 0xe3f0, { 18, 18, 12}},
{"m68k_op_roxr_16_ai ", 0xfff8, 0xe4d0, { 12, 12, 9}},
{"m68k_op_roxr_16_pi ", 0xfff8, 0xe4d8, { 12, 12, 9}},
{"m68k_op_roxr_16_pd ", 0xfff8, 0xe4e0, { 14, 14, 10}},
{"m68k_op_roxr_16_di ", 0xfff8, 0xe4e8, { 16, 16, 10}},
{"m68k_op_roxr_16_ix ", 0xfff8, 0xe4f0, { 18, 18, 12}},
{"m68k_op_roxl_16_ai ", 0xfff8, 0xe5d0, { 12, 12, 9}},
{"m68k_op_roxl_16_pi ", 0xfff8, 0xe5d8, { 12, 12, 9}},
{"m68k_op_roxl_16_pd ", 0xfff8, 0xe5e0, { 14, 14, 10}},
{"m68k_op_roxl_16_di ", 0xfff8, 0xe5e8, { 16, 16, 10}},
{"m68k_op_roxl_16_ix ", 0xfff8, 0xe5f0, { 18, 18, 12}},
{"m68k_op_ror_16_ai ", 0xfff8, 0xe6d0, { 12, 12, 11}},
{"m68k_op_ror_16_pi ", 0xfff8, 0xe6d8, { 12, 12, 11}},
{"m68k_op_ror_16_pd ", 0xfff8, 0xe6e0, { 14, 14, 12}},
{"m68k_op_ror_16_di ", 0xfff8, 0xe6e8, { 16, 16, 12}},
{"m68k_op_ror_16_ix ", 0xfff8, 0xe6f0, { 18, 18, 14}},
{"m68k_op_rol_16_ai ", 0xfff8, 0xe7d0, { 12, 12, 11}},
{"m68k_op_rol_16_pi ", 0xfff8, 0xe7d8, { 12, 12, 11}},
{"m68k_op_rol_16_pd ", 0xfff8, 0xe7e0, { 14, 14, 12}},
{"m68k_op_rol_16_di ", 0xfff8, 0xe7e8, { 16, 16, 12}},
{"m68k_op_rol_16_ix ", 0xfff8, 0xe7f0, { 18, 18, 14}},
{"m68k_op_bftst_32_d ", 0xfff8, 0xe8c0, { 0, 0, 6}},
{"m68k_op_bftst_32_ai ", 0xfff8, 0xe8d0, { 0, 0, 17}},
{"m68k_op_bftst_32_di ", 0xfff8, 0xe8e8, { 0, 0, 18}},
{"m68k_op_bftst_32_ix ", 0xfff8, 0xe8f0, { 0, 0, 20}},
{"m68k_op_bfextu_32_d ", 0xfff8, 0xe9c0, { 0, 0, 8}},
{"m68k_op_bfextu_32_ai ", 0xfff8, 0xe9d0, { 0, 0, 19}},
{"m68k_op_bfextu_32_di ", 0xfff8, 0xe9e8, { 0, 0, 20}},
{"m68k_op_bfextu_32_ix ", 0xfff8, 0xe9f0, { 0, 0, 22}},
{"m68k_op_bfchg_32_d ", 0xfff8, 0xeac0, { 0, 0, 12}},
{"m68k_op_bfchg_32_ai ", 0xfff8, 0xead0, { 0, 0, 24}},
{"m68k_op_bfchg_32_di ", 0xfff8, 0xeae8, { 0, 0, 25}},
{"m68k_op_bfchg_32_ix ", 0xfff8, 0xeaf0, { 0, 0, 27}},
{"m68k_op_bfexts_32_d ", 0xfff8, 0xebc0, { 0, 0, 8}},
{"m68k_op_bfexts_32_ai ", 0xfff8, 0xebd0, { 0, 0, 19}},
{"m68k_op_bfexts_32_di ", 0xfff8, 0xebe8, { 0, 0, 20}},
{"m68k_op_bfexts_32_ix ", 0xfff8, 0xebf0, { 0, 0, 22}},
{"m68k_op_bfclr_32_d ", 0xfff8, 0xecc0, { 0, 0, 12}},
{"m68k_op_bfclr_32_ai ", 0xfff8, 0xecd0, { 0, 0, 24}},
{"m68k_op_bfclr_32_di ", 0xfff8, 0xece8, { 0, 0, 25}},
{"m68k_op_bfclr_32_ix ", 0xfff8, 0xecf0, { 0, 0, 27}},
{"m68k_op_bfffo_32_d ", 0xfff8, 0xedc0, { 0, 0, 18}},
{"m68k_op_bfffo_32_ai ", 0xfff8, 0xedd0, { 0, 0, 32}},
{"m68k_op_bfffo_32_di ", 0xfff8, 0xede8, { 0, 0, 33}},
{"m68k_op_bfffo_32_ix ", 0xfff8, 0xedf0, { 0, 0, 35}},
{"m68k_op_bfset_32_d ", 0xfff8, 0xeec0, { 0, 0, 12}},
{"m68k_op_bfset_32_ai ", 0xfff8, 0xeed0, { 0, 0, 24}},
{"m68k_op_bfset_32_di ", 0xfff8, 0xeee8, { 0, 0, 25}},
{"m68k_op_bfset_32_ix ", 0xfff8, 0xeef0, { 0, 0, 27}},
{"m68k_op_bfins_32_d ", 0xfff8, 0xefc0, { 0, 0, 10}},
{"m68k_op_bfins_32_ai ", 0xfff8, 0xefd0, { 0, 0, 21}},
{"m68k_op_bfins_32_di ", 0xfff8, 0xefe8, { 0, 0, 22}},
{"m68k_op_bfins_32_ix ", 0xfff8, 0xeff0, { 0, 0, 24}},
{"m68k_op_ori_8_pi7 ", 0xffff, 0x001f, { 16, 16, 8}},
{"m68k_op_ori_8_pd7 ", 0xffff, 0x0027, { 18, 18, 9}},
{"m68k_op_ori_8_aw ", 0xffff, 0x0038, { 20, 20, 8}},
{"m68k_op_ori_8_al ", 0xffff, 0x0039, { 24, 24, 8}},
{"m68k_op_ori_16_toc ", 0xffff, 0x003c, { 20, 16, 12}},
{"m68k_op_ori_16_aw ", 0xffff, 0x0078, { 20, 20, 8}},
{"m68k_op_ori_16_al ", 0xffff, 0x0079, { 24, 24, 8}},
{"m68k_op_ori_16_tos ", 0xffff, 0x007c, { 20, 16, 12}},
{"m68k_op_ori_32_aw ", 0xffff, 0x00b8, { 32, 32, 8}},
{"m68k_op_ori_32_al ", 0xffff, 0x00b9, { 36, 36, 8}},
{"m68k_op_chk2cmp2_8_aw ", 0xffff, 0x00f8, { 0, 0, 22}},
{"m68k_op_chk2cmp2_8_al ", 0xffff, 0x00f9, { 0, 0, 22}},
{"m68k_op_chk2cmp2_8_pcdi ", 0xffff, 0x00fa, { 0, 0, 23}},
{"m68k_op_chk2cmp2_8_pcix ", 0xffff, 0x00fb, { 0, 0, 23}},
{"m68k_op_andi_8_pi7 ", 0xffff, 0x021f, { 16, 16, 8}},
{"m68k_op_andi_8_pd7 ", 0xffff, 0x0227, { 18, 18, 9}},
{"m68k_op_andi_8_aw ", 0xffff, 0x0238, { 20, 20, 8}},
{"m68k_op_andi_8_al ", 0xffff, 0x0239, { 24, 24, 8}},
{"m68k_op_andi_16_toc ", 0xffff, 0x023c, { 20, 16, 12}},
{"m68k_op_andi_16_aw ", 0xffff, 0x0278, { 20, 20, 8}},
{"m68k_op_andi_16_al ", 0xffff, 0x0279, { 24, 24, 8}},
{"m68k_op_andi_16_tos ", 0xffff, 0x027c, { 20, 16, 12}},
{"m68k_op_andi_32_aw ", 0xffff, 0x02b8, { 32, 32, 8}},
{"m68k_op_andi_32_al ", 0xffff, 0x02b9, { 36, 36, 8}},
{"m68k_op_chk2cmp2_16_aw ", 0xffff, 0x02f8, { 0, 0, 22}},
{"m68k_op_chk2cmp2_16_al ", 0xffff, 0x02f9, { 0, 0, 22}},
{"m68k_op_chk2cmp2_16_pcdi ", 0xffff, 0x02fa, { 0, 0, 23}},
{"m68k_op_chk2cmp2_16_pcix ", 0xffff, 0x02fb, { 0, 0, 23}},
{"m68k_op_subi_8_pi7 ", 0xffff, 0x041f, { 16, 16, 8}},
{"m68k_op_subi_8_pd7 ", 0xffff, 0x0427, { 18, 18, 9}},
{"m68k_op_subi_8_aw ", 0xffff, 0x0438, { 20, 20, 8}},
{"m68k_op_subi_8_al ", 0xffff, 0x0439, { 24, 24, 8}},
{"m68k_op_subi_16_aw ", 0xffff, 0x0478, { 20, 20, 8}},
{"m68k_op_subi_16_al ", 0xffff, 0x0479, { 24, 24, 8}},
{"m68k_op_subi_32_aw ", 0xffff, 0x04b8, { 32, 32, 8}},
{"m68k_op_subi_32_al ", 0xffff, 0x04b9, { 36, 36, 8}},
{"m68k_op_chk2cmp2_32_aw ", 0xffff, 0x04f8, { 0, 0, 22}},
{"m68k_op_chk2cmp2_32_al ", 0xffff, 0x04f9, { 0, 0, 22}},
{"m68k_op_chk2cmp2_32_pcdi ", 0xffff, 0x04fa, { 0, 0, 23}},
{"m68k_op_chk2cmp2_32_pcix ", 0xffff, 0x04fb, { 0, 0, 23}},
{"m68k_op_addi_8_pi7 ", 0xffff, 0x061f, { 16, 16, 8}},
{"m68k_op_addi_8_pd7 ", 0xffff, 0x0627, { 18, 18, 9}},
{"m68k_op_addi_8_aw ", 0xffff, 0x0638, { 20, 20, 8}},
{"m68k_op_addi_8_al ", 0xffff, 0x0639, { 24, 24, 8}},
{"m68k_op_addi_16_aw ", 0xffff, 0x0678, { 20, 20, 8}},
{"m68k_op_addi_16_al ", 0xffff, 0x0679, { 24, 24, 8}},
{"m68k_op_addi_32_aw ", 0xffff, 0x06b8, { 32, 32, 8}},
{"m68k_op_addi_32_al ", 0xffff, 0x06b9, { 36, 36, 8}},
{"m68k_op_callm_32_aw ", 0xffff, 0x06f8, { 0, 0, 64}},
{"m68k_op_callm_32_al ", 0xffff, 0x06f9, { 0, 0, 64}},
{"m68k_op_callm_32_pcdi ", 0xffff, 0x06fa, { 0, 0, 65}},
{"m68k_op_callm_32_pcix ", 0xffff, 0x06fb, { 0, 0, 67}},
{"m68k_op_btst_8_s_pi7 ", 0xffff, 0x081f, { 12, 12, 8}},
{"m68k_op_btst_8_s_pd7 ", 0xffff, 0x0827, { 14, 14, 9}},
{"m68k_op_btst_8_s_aw ", 0xffff, 0x0838, { 16, 16, 8}},
{"m68k_op_btst_8_s_al ", 0xffff, 0x0839, { 20, 20, 8}},
{"m68k_op_btst_8_s_pcdi ", 0xffff, 0x083a, { 16, 16, 9}},
{"m68k_op_btst_8_s_pcix ", 0xffff, 0x083b, { 18, 18, 11}},
{"m68k_op_bchg_8_s_pi7 ", 0xffff, 0x085f, { 16, 16, 8}},
{"m68k_op_bchg_8_s_pd7 ", 0xffff, 0x0867, { 18, 18, 9}},
{"m68k_op_bchg_8_s_aw ", 0xffff, 0x0878, { 20, 20, 8}},
{"m68k_op_bchg_8_s_al ", 0xffff, 0x0879, { 24, 24, 8}},
{"m68k_op_bclr_8_s_pi7 ", 0xffff, 0x089f, { 16, 16, 8}},
{"m68k_op_bclr_8_s_pd7 ", 0xffff, 0x08a7, { 18, 18, 9}},
{"m68k_op_bclr_8_s_aw ", 0xffff, 0x08b8, { 20, 20, 8}},
{"m68k_op_bclr_8_s_al ", 0xffff, 0x08b9, { 24, 24, 8}},
{"m68k_op_bset_8_s_pi7 ", 0xffff, 0x08df, { 16, 16, 8}},
{"m68k_op_bset_8_s_pd7 ", 0xffff, 0x08e7, { 18, 18, 9}},
{"m68k_op_bset_8_s_aw ", 0xffff, 0x08f8, { 20, 20, 8}},
{"m68k_op_bset_8_s_al ", 0xffff, 0x08f9, { 24, 24, 8}},
{"m68k_op_eori_8_pi7 ", 0xffff, 0x0a1f, { 16, 16, 8}},
{"m68k_op_eori_8_pd7 ", 0xffff, 0x0a27, { 18, 18, 9}},
{"m68k_op_eori_8_aw ", 0xffff, 0x0a38, { 20, 20, 8}},
{"m68k_op_eori_8_al ", 0xffff, 0x0a39, { 24, 24, 8}},
{"m68k_op_eori_16_toc ", 0xffff, 0x0a3c, { 20, 16, 12}},
{"m68k_op_eori_16_aw ", 0xffff, 0x0a78, { 20, 20, 8}},
{"m68k_op_eori_16_al ", 0xffff, 0x0a79, { 24, 24, 8}},
{"m68k_op_eori_16_tos ", 0xffff, 0x0a7c, { 20, 16, 12}},
{"m68k_op_eori_32_aw ", 0xffff, 0x0ab8, { 32, 32, 8}},
{"m68k_op_eori_32_al ", 0xffff, 0x0ab9, { 36, 36, 8}},
{"m68k_op_cas_8_pi7 ", 0xffff, 0x0adf, { 0, 0, 16}},
{"m68k_op_cas_8_pd7 ", 0xffff, 0x0ae7, { 0, 0, 17}},
{"m68k_op_cas_8_aw ", 0xffff, 0x0af8, { 0, 0, 16}},
{"m68k_op_cas_8_al ", 0xffff, 0x0af9, { 0, 0, 16}},
{"m68k_op_cmpi_8_pi7 ", 0xffff, 0x0c1f, { 12, 12, 6}},
{"m68k_op_cmpi_8_pd7 ", 0xffff, 0x0c27, { 14, 14, 7}},
{"m68k_op_cmpi_8_aw ", 0xffff, 0x0c38, { 16, 16, 6}},
{"m68k_op_cmpi_8_al ", 0xffff, 0x0c39, { 20, 20, 6}},
{"m68k_op_cmpi_8_pcdi ", 0xffff, 0x0c3a, { 0, 0, 7}},
{"m68k_op_cmpi_8_pcix ", 0xffff, 0x0c3b, { 0, 0, 9}},
{"m68k_op_cmpi_16_aw ", 0xffff, 0x0c78, { 16, 16, 6}},
{"m68k_op_cmpi_16_al ", 0xffff, 0x0c79, { 20, 20, 6}},
{"m68k_op_cmpi_16_pcdi ", 0xffff, 0x0c7a, { 0, 0, 7}},
{"m68k_op_cmpi_16_pcix ", 0xffff, 0x0c7b, { 0, 0, 9}},
{"m68k_op_cmpi_32_aw ", 0xffff, 0x0cb8, { 24, 24, 6}},
{"m68k_op_cmpi_32_al ", 0xffff, 0x0cb9, { 28, 28, 6}},
{"m68k_op_cmpi_32_pcdi ", 0xffff, 0x0cba, { 0, 0, 7}},
{"m68k_op_cmpi_32_pcix ", 0xffff, 0x0cbb, { 0, 0, 9}},
{"m68k_op_cas_16_aw ", 0xffff, 0x0cf8, { 0, 0, 16}},
{"m68k_op_cas_16_al ", 0xffff, 0x0cf9, { 0, 0, 16}},
{"m68k_op_cas2_16 ", 0xffff, 0x0cfc, { 0, 0, 12}},
{"m68k_op_moves_8_pi7 ", 0xffff, 0x0e1f, { 0, 18, 9}},
{"m68k_op_moves_8_pd7 ", 0xffff, 0x0e27, { 0, 20, 10}},
{"m68k_op_moves_8_aw ", 0xffff, 0x0e38, { 0, 26, 9}},
{"m68k_op_moves_8_al ", 0xffff, 0x0e39, { 0, 30, 9}},
{"m68k_op_moves_16_aw ", 0xffff, 0x0e78, { 0, 26, 9}},
{"m68k_op_moves_16_al ", 0xffff, 0x0e79, { 0, 30, 9}},
{"m68k_op_moves_32_aw ", 0xffff, 0x0eb8, { 0, 32, 9}},
{"m68k_op_moves_32_al ", 0xffff, 0x0eb9, { 0, 36, 9}},
{"m68k_op_cas_32_aw ", 0xffff, 0x0ef8, { 0, 0, 16}},
{"m68k_op_cas_32_al ", 0xffff, 0x0ef9, { 0, 0, 16}},
{"m68k_op_cas2_32 ", 0xffff, 0x0efc, { 0, 0, 12}},
{"m68k_op_move_8_aw_pi7 ", 0xffff, 0x11df, { 16, 16, 8}},
{"m68k_op_move_8_aw_pd7 ", 0xffff, 0x11e7, { 18, 18, 9}},
{"m68k_op_move_8_aw_aw ", 0xffff, 0x11f8, { 20, 20, 8}},
{"m68k_op_move_8_aw_al ", 0xffff, 0x11f9, { 24, 24, 8}},
{"m68k_op_move_8_aw_pcdi ", 0xffff, 0x11fa, { 20, 20, 9}},
{"m68k_op_move_8_aw_pcix ", 0xffff, 0x11fb, { 22, 22, 11}},
{"m68k_op_move_8_aw_i ", 0xffff, 0x11fc, { 16, 16, 6}},
{"m68k_op_move_8_al_pi7 ", 0xffff, 0x13df, { 20, 20, 10}},
{"m68k_op_move_8_al_pd7 ", 0xffff, 0x13e7, { 22, 22, 11}},
{"m68k_op_move_8_al_aw ", 0xffff, 0x13f8, { 24, 24, 10}},
{"m68k_op_move_8_al_al ", 0xffff, 0x13f9, { 28, 28, 10}},
{"m68k_op_move_8_al_pcdi ", 0xffff, 0x13fa, { 24, 24, 11}},
{"m68k_op_move_8_al_pcix ", 0xffff, 0x13fb, { 26, 26, 13}},
{"m68k_op_move_8_al_i ", 0xffff, 0x13fc, { 20, 20, 8}},
{"m68k_op_move_8_pi7_pi7 ", 0xffff, 0x1edf, { 12, 12, 8}},
{"m68k_op_move_8_pi7_pd7 ", 0xffff, 0x1ee7, { 14, 14, 9}},
{"m68k_op_move_8_pi7_aw ", 0xffff, 0x1ef8, { 16, 16, 8}},
{"m68k_op_move_8_pi7_al ", 0xffff, 0x1ef9, { 20, 20, 8}},
{"m68k_op_move_8_pi7_pcdi ", 0xffff, 0x1efa, { 16, 16, 9}},
{"m68k_op_move_8_pi7_pcix ", 0xffff, 0x1efb, { 18, 18, 11}},
{"m68k_op_move_8_pi7_i ", 0xffff, 0x1efc, { 12, 12, 6}},
{"m68k_op_move_8_pd7_pi7 ", 0xffff, 0x1f1f, { 12, 12, 9}},
{"m68k_op_move_8_pd7_pd7 ", 0xffff, 0x1f27, { 14, 14, 10}},
{"m68k_op_move_8_pd7_aw ", 0xffff, 0x1f38, { 16, 16, 9}},
{"m68k_op_move_8_pd7_al ", 0xffff, 0x1f39, { 20, 20, 9}},
{"m68k_op_move_8_pd7_pcdi ", 0xffff, 0x1f3a, { 16, 16, 10}},
{"m68k_op_move_8_pd7_pcix ", 0xffff, 0x1f3b, { 18, 18, 12}},
{"m68k_op_move_8_pd7_i ", 0xffff, 0x1f3c, { 12, 12, 7}},
{"m68k_op_move_32_aw_aw ", 0xffff, 0x21f8, { 28, 28, 8}},
{"m68k_op_move_32_aw_al ", 0xffff, 0x21f9, { 32, 32, 8}},
{"m68k_op_move_32_aw_pcdi ", 0xffff, 0x21fa, { 28, 28, 9}},
{"m68k_op_move_32_aw_pcix ", 0xffff, 0x21fb, { 30, 30, 11}},
{"m68k_op_move_32_aw_i ", 0xffff, 0x21fc, { 24, 24, 8}},
{"m68k_op_move_32_al_aw ", 0xffff, 0x23f8, { 32, 32, 10}},
{"m68k_op_move_32_al_al ", 0xffff, 0x23f9, { 36, 36, 10}},
{"m68k_op_move_32_al_pcdi ", 0xffff, 0x23fa, { 32, 32, 11}},
{"m68k_op_move_32_al_pcix ", 0xffff, 0x23fb, { 34, 34, 13}},
{"m68k_op_move_32_al_i ", 0xffff, 0x23fc, { 28, 28, 10}},
{"m68k_op_move_16_aw_aw ", 0xffff, 0x31f8, { 20, 20, 8}},
{"m68k_op_move_16_aw_al ", 0xffff, 0x31f9, { 24, 24, 8}},
{"m68k_op_move_16_aw_pcdi ", 0xffff, 0x31fa, { 20, 20, 9}},
{"m68k_op_move_16_aw_pcix ", 0xffff, 0x31fb, { 22, 22, 11}},
{"m68k_op_move_16_aw_i ", 0xffff, 0x31fc, { 16, 16, 6}},
{"m68k_op_move_16_al_aw ", 0xffff, 0x33f8, { 24, 24, 10}},
{"m68k_op_move_16_al_al ", 0xffff, 0x33f9, { 28, 28, 10}},
{"m68k_op_move_16_al_pcdi ", 0xffff, 0x33fa, { 24, 24, 11}},
{"m68k_op_move_16_al_pcix ", 0xffff, 0x33fb, { 26, 26, 13}},
{"m68k_op_move_16_al_i ", 0xffff, 0x33fc, { 20, 20, 8}},
{"m68k_op_negx_8_pi7 ", 0xffff, 0x401f, { 12, 12, 8}},
{"m68k_op_negx_8_pd7 ", 0xffff, 0x4027, { 14, 14, 9}},
{"m68k_op_negx_8_aw ", 0xffff, 0x4038, { 16, 16, 8}},
{"m68k_op_negx_8_al ", 0xffff, 0x4039, { 20, 20, 8}},
{"m68k_op_negx_16_aw ", 0xffff, 0x4078, { 16, 16, 8}},
{"m68k_op_negx_16_al ", 0xffff, 0x4079, { 20, 20, 8}},
{"m68k_op_negx_32_aw ", 0xffff, 0x40b8, { 24, 24, 8}},
{"m68k_op_negx_32_al ", 0xffff, 0x40b9, { 28, 28, 8}},
{"m68k_op_move_16_frs_aw ", 0xffff, 0x40f8, { 16, 16, 12}},
{"m68k_op_move_16_frs_al ", 0xffff, 0x40f9, { 20, 20, 12}},
{"m68k_op_clr_8_pi7 ", 0xffff, 0x421f, { 12, 8, 8}},
{"m68k_op_clr_8_pd7 ", 0xffff, 0x4227, { 14, 10, 9}},
{"m68k_op_clr_8_aw ", 0xffff, 0x4238, { 16, 12, 8}},
{"m68k_op_clr_8_al ", 0xffff, 0x4239, { 20, 14, 8}},
{"m68k_op_clr_16_aw ", 0xffff, 0x4278, { 16, 12, 8}},
{"m68k_op_clr_16_al ", 0xffff, 0x4279, { 20, 14, 8}},
{"m68k_op_clr_32_aw ", 0xffff, 0x42b8, { 24, 16, 8}},
{"m68k_op_clr_32_al ", 0xffff, 0x42b9, { 28, 20, 8}},
{"m68k_op_move_16_frc_aw ", 0xffff, 0x42f8, { 0, 16, 8}},
{"m68k_op_move_16_frc_al ", 0xffff, 0x42f9, { 0, 20, 8}},
{"m68k_op_neg_8_pi7 ", 0xffff, 0x441f, { 12, 12, 8}},
{"m68k_op_neg_8_pd7 ", 0xffff, 0x4427, { 14, 14, 9}},
{"m68k_op_neg_8_aw ", 0xffff, 0x4438, { 16, 16, 8}},
{"m68k_op_neg_8_al ", 0xffff, 0x4439, { 20, 20, 8}},
{"m68k_op_neg_16_aw ", 0xffff, 0x4478, { 16, 16, 8}},
{"m68k_op_neg_16_al ", 0xffff, 0x4479, { 20, 20, 8}},
{"m68k_op_neg_32_aw ", 0xffff, 0x44b8, { 24, 24, 8}},
{"m68k_op_neg_32_al ", 0xffff, 0x44b9, { 28, 28, 8}},
{"m68k_op_move_16_toc_aw ", 0xffff, 0x44f8, { 20, 20, 8}},
{"m68k_op_move_16_toc_al ", 0xffff, 0x44f9, { 24, 24, 8}},
{"m68k_op_move_16_toc_pcdi ", 0xffff, 0x44fa, { 20, 20, 9}},
{"m68k_op_move_16_toc_pcix ", 0xffff, 0x44fb, { 22, 22, 11}},
{"m68k_op_move_16_toc_i ", 0xffff, 0x44fc, { 16, 16, 6}},
{"m68k_op_not_8_pi7 ", 0xffff, 0x461f, { 12, 12, 8}},
{"m68k_op_not_8_pd7 ", 0xffff, 0x4627, { 14, 14, 9}},
{"m68k_op_not_8_aw ", 0xffff, 0x4638, { 16, 16, 8}},
{"m68k_op_not_8_al ", 0xffff, 0x4639, { 20, 20, 8}},
{"m68k_op_not_16_aw ", 0xffff, 0x4678, { 16, 16, 8}},
{"m68k_op_not_16_al ", 0xffff, 0x4679, { 20, 20, 8}},
{"m68k_op_not_32_aw ", 0xffff, 0x46b8, { 24, 24, 8}},
{"m68k_op_not_32_al ", 0xffff, 0x46b9, { 28, 28, 8}},
{"m68k_op_move_16_tos_aw ", 0xffff, 0x46f8, { 20, 20, 12}},
{"m68k_op_move_16_tos_al ", 0xffff, 0x46f9, { 24, 24, 12}},
{"m68k_op_move_16_tos_pcdi ", 0xffff, 0x46fa, { 20, 20, 13}},
{"m68k_op_move_16_tos_pcix ", 0xffff, 0x46fb, { 22, 22, 15}},
{"m68k_op_move_16_tos_i ", 0xffff, 0x46fc, { 16, 16, 10}},
{"m68k_op_link_32_a7 ", 0xffff, 0x480f, { 0, 0, 6}},
{"m68k_op_nbcd_8_pi7 ", 0xffff, 0x481f, { 12, 12, 10}},
{"m68k_op_nbcd_8_pd7 ", 0xffff, 0x4827, { 14, 14, 11}},
{"m68k_op_nbcd_8_aw ", 0xffff, 0x4838, { 16, 16, 10}},
{"m68k_op_nbcd_8_al ", 0xffff, 0x4839, { 20, 20, 10}},
{"m68k_op_pea_32_aw ", 0xffff, 0x4878, { 16, 16, 9}},
{"m68k_op_pea_32_al ", 0xffff, 0x4879, { 20, 20, 9}},
{"m68k_op_pea_32_pcdi ", 0xffff, 0x487a, { 16, 16, 10}},
{"m68k_op_pea_32_pcix ", 0xffff, 0x487b, { 20, 20, 12}},
{"m68k_op_movem_16_re_aw ", 0xffff, 0x48b8, { 12, 12, 8}},
{"m68k_op_movem_16_re_al ", 0xffff, 0x48b9, { 16, 16, 8}},
{"m68k_op_movem_32_re_aw ", 0xffff, 0x48f8, { 12, 12, 8}},
{"m68k_op_movem_32_re_al ", 0xffff, 0x48f9, { 16, 16, 8}},
{"m68k_op_tst_8_pi7 ", 0xffff, 0x4a1f, { 8, 8, 6}},
{"m68k_op_tst_8_pd7 ", 0xffff, 0x4a27, { 10, 10, 7}},
{"m68k_op_tst_8_aw ", 0xffff, 0x4a38, { 12, 12, 6}},
{"m68k_op_tst_8_al ", 0xffff, 0x4a39, { 16, 16, 6}},
{"m68k_op_tst_8_pcdi ", 0xffff, 0x4a3a, { 0, 0, 7}},
{"m68k_op_tst_8_pcix ", 0xffff, 0x4a3b, { 0, 0, 9}},
{"m68k_op_tst_8_i ", 0xffff, 0x4a3c, { 0, 0, 6}},
{"m68k_op_tst_16_aw ", 0xffff, 0x4a78, { 12, 12, 6}},
{"m68k_op_tst_16_al ", 0xffff, 0x4a79, { 16, 16, 6}},
{"m68k_op_tst_16_pcdi ", 0xffff, 0x4a7a, { 0, 0, 7}},
{"m68k_op_tst_16_pcix ", 0xffff, 0x4a7b, { 0, 0, 9}},
{"m68k_op_tst_16_i ", 0xffff, 0x4a7c, { 0, 0, 6}},
{"m68k_op_tst_32_aw ", 0xffff, 0x4ab8, { 16, 16, 6}},
{"m68k_op_tst_32_al ", 0xffff, 0x4ab9, { 20, 20, 6}},
{"m68k_op_tst_32_pcdi ", 0xffff, 0x4aba, { 0, 0, 7}},
{"m68k_op_tst_32_pcix ", 0xffff, 0x4abb, { 0, 0, 9}},
{"m68k_op_tst_32_i ", 0xffff, 0x4abc, { 0, 0, 6}},
{"m68k_op_tas_8_pi7 ", 0xffff, 0x4adf, { 18, 18, 16}},
{"m68k_op_tas_8_pd7 ", 0xffff, 0x4ae7, { 20, 20, 17}},
{"m68k_op_tas_8_aw ", 0xffff, 0x4af8, { 22, 22, 16}},
{"m68k_op_tas_8_al ", 0xffff, 0x4af9, { 26, 26, 16}},
{"m68k_op_illegal ", 0xffff, 0x4afc, { 4, 4, 4}},
{"m68k_op_mull_32_aw ", 0xffff, 0x4c38, { 0, 0, 47}},
{"m68k_op_mull_32_al ", 0xffff, 0x4c39, { 0, 0, 47}},
{"m68k_op_mull_32_pcdi ", 0xffff, 0x4c3a, { 0, 0, 48}},
{"m68k_op_mull_32_pcix ", 0xffff, 0x4c3b, { 0, 0, 50}},
{"m68k_op_mull_32_i ", 0xffff, 0x4c3c, { 0, 0, 47}},
{"m68k_op_divl_32_aw ", 0xffff, 0x4c78, { 0, 0, 88}},
{"m68k_op_divl_32_al ", 0xffff, 0x4c79, { 0, 0, 88}},
{"m68k_op_divl_32_pcdi ", 0xffff, 0x4c7a, { 0, 0, 89}},
{"m68k_op_divl_32_pcix ", 0xffff, 0x4c7b, { 0, 0, 91}},
{"m68k_op_divl_32_i ", 0xffff, 0x4c7c, { 0, 0, 88}},
{"m68k_op_movem_16_er_aw ", 0xffff, 0x4cb8, { 16, 16, 12}},
{"m68k_op_movem_16_er_al ", 0xffff, 0x4cb9, { 20, 20, 12}},
{"m68k_op_movem_16_er_pcdi ", 0xffff, 0x4cba, { 16, 16, 9}},
{"m68k_op_movem_16_er_pcix ", 0xffff, 0x4cbb, { 18, 18, 11}},
{"m68k_op_movem_32_er_aw ", 0xffff, 0x4cf8, { 16, 16, 12}},
{"m68k_op_movem_32_er_al ", 0xffff, 0x4cf9, { 20, 20, 12}},
{"m68k_op_movem_32_er_pcdi ", 0xffff, 0x4cfa, { 16, 16, 9}},
{"m68k_op_movem_32_er_pcix ", 0xffff, 0x4cfb, { 18, 18, 11}},
{"m68k_op_link_16_a7 ", 0xffff, 0x4e57, { 16, 16, 5}},
{"m68k_op_unlk_32_a7 ", 0xffff, 0x4e5f, { 12, 12, 6}},
{"m68k_op_reset ", 0xffff, 0x4e70, { 0, 0, 0}},
{"m68k_op_nop ", 0xffff, 0x4e71, { 4, 4, 2}},
{"m68k_op_stop ", 0xffff, 0x4e72, { 4, 4, 8}},
{"m68k_op_rte_32 ", 0xffff, 0x4e73, { 20, 24, 20}},
{"m68k_op_rtd_32 ", 0xffff, 0x4e74, { 0, 16, 10}},
{"m68k_op_rts_32 ", 0xffff, 0x4e75, { 16, 16, 10}},
{"m68k_op_trapv ", 0xffff, 0x4e76, { 4, 4, 4}},
{"m68k_op_rtr_32 ", 0xffff, 0x4e77, { 20, 20, 14}},
{"m68k_op_movec_32_cr ", 0xffff, 0x4e7a, { 0, 12, 6}},
{"m68k_op_movec_32_rc ", 0xffff, 0x4e7b, { 0, 10, 12}},
{"m68k_op_jsr_32_aw ", 0xffff, 0x4eb8, { 18, 18, 4}},
{"m68k_op_jsr_32_al ", 0xffff, 0x4eb9, { 20, 20, 4}},
{"m68k_op_jsr_32_pcdi ", 0xffff, 0x4eba, { 18, 18, 5}},
{"m68k_op_jsr_32_pcix ", 0xffff, 0x4ebb, { 22, 22, 7}},
{"m68k_op_jmp_32_aw ", 0xffff, 0x4ef8, { 10, 10, 4}},
{"m68k_op_jmp_32_al ", 0xffff, 0x4ef9, { 12, 12, 4}},
{"m68k_op_jmp_32_pcdi ", 0xffff, 0x4efa, { 10, 10, 5}},
{"m68k_op_jmp_32_pcix ", 0xffff, 0x4efb, { 14, 14, 7}},
{"m68k_op_st_8_pi7 ", 0xffff, 0x50df, { 12, 12, 10}},
{"m68k_op_st_8_pd7 ", 0xffff, 0x50e7, { 14, 14, 11}},
{"m68k_op_st_8_aw ", 0xffff, 0x50f8, { 16, 16, 10}},
{"m68k_op_st_8_al ", 0xffff, 0x50f9, { 20, 20, 10}},
{"m68k_op_trapt_16 ", 0xffff, 0x50fa, { 0, 0, 6}},
{"m68k_op_trapt_32 ", 0xffff, 0x50fb, { 0, 0, 8}},
{"m68k_op_trapt ", 0xffff, 0x50fc, { 0, 0, 4}},
{"m68k_op_sf_8_pi7 ", 0xffff, 0x51df, { 12, 12, 10}},
{"m68k_op_sf_8_pd7 ", 0xffff, 0x51e7, { 14, 14, 11}},
{"m68k_op_sf_8_aw ", 0xffff, 0x51f8, { 16, 16, 10}},
{"m68k_op_sf_8_al ", 0xffff, 0x51f9, { 20, 20, 10}},
{"m68k_op_trapf_16 ", 0xffff, 0x51fa, { 0, 0, 6}},
{"m68k_op_trapf_32 ", 0xffff, 0x51fb, { 0, 0, 8}},
{"m68k_op_trapf ", 0xffff, 0x51fc, { 0, 0, 4}},
{"m68k_op_shi_8_pi7 ", 0xffff, 0x52df, { 12, 12, 10}},
{"m68k_op_shi_8_pd7 ", 0xffff, 0x52e7, { 14, 14, 11}},
{"m68k_op_shi_8_aw ", 0xffff, 0x52f8, { 16, 16, 10}},
{"m68k_op_shi_8_al ", 0xffff, 0x52f9, { 20, 20, 10}},
{"m68k_op_traphi_16 ", 0xffff, 0x52fa, { 0, 0, 6}},
{"m68k_op_traphi_32 ", 0xffff, 0x52fb, { 0, 0, 8}},
{"m68k_op_traphi ", 0xffff, 0x52fc, { 0, 0, 4}},
{"m68k_op_sls_8_pi7 ", 0xffff, 0x53df, { 12, 12, 10}},
{"m68k_op_sls_8_pd7 ", 0xffff, 0x53e7, { 14, 14, 11}},
{"m68k_op_sls_8_aw ", 0xffff, 0x53f8, { 16, 16, 10}},
{"m68k_op_sls_8_al ", 0xffff, 0x53f9, { 20, 20, 10}},
{"m68k_op_trapls_16 ", 0xffff, 0x53fa, { 0, 0, 6}},
{"m68k_op_trapls_32 ", 0xffff, 0x53fb, { 0, 0, 8}},
{"m68k_op_trapls ", 0xffff, 0x53fc, { 0, 0, 4}},
{"m68k_op_scc_8_pi7 ", 0xffff, 0x54df, { 12, 12, 10}},
{"m68k_op_scc_8_pd7 ", 0xffff, 0x54e7, { 14, 14, 11}},
{"m68k_op_scc_8_aw ", 0xffff, 0x54f8, { 16, 16, 10}},
{"m68k_op_scc_8_al ", 0xffff, 0x54f9, { 20, 20, 10}},
{"m68k_op_trapcc_16 ", 0xffff, 0x54fa, { 0, 0, 6}},
{"m68k_op_trapcc_32 ", 0xffff, 0x54fb, { 0, 0, 8}},
{"m68k_op_trapcc ", 0xffff, 0x54fc, { 0, 0, 4}},
{"m68k_op_scs_8_pi7 ", 0xffff, 0x55df, { 12, 12, 10}},
{"m68k_op_scs_8_pd7 ", 0xffff, 0x55e7, { 14, 14, 11}},
{"m68k_op_scs_8_aw ", 0xffff, 0x55f8, { 16, 16, 10}},
{"m68k_op_scs_8_al ", 0xffff, 0x55f9, { 20, 20, 10}},
{"m68k_op_trapcs_16 ", 0xffff, 0x55fa, { 0, 0, 6}},
{"m68k_op_trapcs_32 ", 0xffff, 0x55fb, { 0, 0, 8}},
{"m68k_op_trapcs ", 0xffff, 0x55fc, { 0, 0, 4}},
{"m68k_op_sne_8_pi7 ", 0xffff, 0x56df, { 12, 12, 10}},
{"m68k_op_sne_8_pd7 ", 0xffff, 0x56e7, { 14, 14, 11}},
{"m68k_op_sne_8_aw ", 0xffff, 0x56f8, { 16, 16, 10}},
{"m68k_op_sne_8_al ", 0xffff, 0x56f9, { 20, 20, 10}},
{"m68k_op_trapne_16 ", 0xffff, 0x56fa, { 0, 0, 6}},
{"m68k_op_trapne_32 ", 0xffff, 0x56fb, { 0, 0, 8}},
{"m68k_op_trapne ", 0xffff, 0x56fc, { 0, 0, 4}},
{"m68k_op_seq_8_pi7 ", 0xffff, 0x57df, { 12, 12, 10}},
{"m68k_op_seq_8_pd7 ", 0xffff, 0x57e7, { 14, 14, 11}},
{"m68k_op_seq_8_aw ", 0xffff, 0x57f8, { 16, 16, 10}},
{"m68k_op_seq_8_al ", 0xffff, 0x57f9, { 20, 20, 10}},
{"m68k_op_trapeq_16 ", 0xffff, 0x57fa, { 0, 0, 6}},
{"m68k_op_trapeq_32 ", 0xffff, 0x57fb, { 0, 0, 8}},
{"m68k_op_trapeq ", 0xffff, 0x57fc, { 0, 0, 4}},
{"m68k_op_svc_8_pi7 ", 0xffff, 0x58df, { 12, 12, 10}},
{"m68k_op_svc_8_pd7 ", 0xffff, 0x58e7, { 14, 14, 11}},
{"m68k_op_svc_8_aw ", 0xffff, 0x58f8, { 16, 16, 10}},
{"m68k_op_svc_8_al ", 0xffff, 0x58f9, { 20, 20, 10}},
{"m68k_op_trapvc_16 ", 0xffff, 0x58fa, { 0, 0, 6}},
{"m68k_op_trapvc_32 ", 0xffff, 0x58fb, { 0, 0, 8}},
{"m68k_op_trapvc ", 0xffff, 0x58fc, { 0, 0, 4}},
{"m68k_op_svs_8_pi7 ", 0xffff, 0x59df, { 12, 12, 10}},
{"m68k_op_svs_8_pd7 ", 0xffff, 0x59e7, { 14, 14, 11}},
{"m68k_op_svs_8_aw ", 0xffff, 0x59f8, { 16, 16, 10}},
{"m68k_op_svs_8_al ", 0xffff, 0x59f9, { 20, 20, 10}},
{"m68k_op_trapvs_16 ", 0xffff, 0x59fa, { 0, 0, 6}},
{"m68k_op_trapvs_32 ", 0xffff, 0x59fb, { 0, 0, 8}},
{"m68k_op_trapvs ", 0xffff, 0x59fc, { 0, 0, 4}},
{"m68k_op_spl_8_pi7 ", 0xffff, 0x5adf, { 12, 12, 10}},
{"m68k_op_spl_8_pd7 ", 0xffff, 0x5ae7, { 14, 14, 11}},
{"m68k_op_spl_8_aw ", 0xffff, 0x5af8, { 16, 16, 10}},
{"m68k_op_spl_8_al ", 0xffff, 0x5af9, { 20, 20, 10}},
{"m68k_op_trappl_16 ", 0xffff, 0x5afa, { 0, 0, 6}},
{"m68k_op_trappl_32 ", 0xffff, 0x5afb, { 0, 0, 8}},
{"m68k_op_trappl ", 0xffff, 0x5afc, { 0, 0, 4}},
{"m68k_op_smi_8_pi7 ", 0xffff, 0x5bdf, { 12, 12, 10}},
{"m68k_op_smi_8_pd7 ", 0xffff, 0x5be7, { 14, 14, 11}},
{"m68k_op_smi_8_aw ", 0xffff, 0x5bf8, { 16, 16, 10}},
{"m68k_op_smi_8_al ", 0xffff, 0x5bf9, { 20, 20, 10}},
{"m68k_op_trapmi_16 ", 0xffff, 0x5bfa, { 0, 0, 6}},
{"m68k_op_trapmi_32 ", 0xffff, 0x5bfb, { 0, 0, 8}},
{"m68k_op_trapmi ", 0xffff, 0x5bfc, { 0, 0, 4}},
{"m68k_op_sge_8_pi7 ", 0xffff, 0x5cdf, { 12, 12, 10}},
{"m68k_op_sge_8_pd7 ", 0xffff, 0x5ce7, { 14, 14, 11}},
{"m68k_op_sge_8_aw ", 0xffff, 0x5cf8, { 16, 16, 10}},
{"m68k_op_sge_8_al ", 0xffff, 0x5cf9, { 20, 20, 10}},
{"m68k_op_trapge_16 ", 0xffff, 0x5cfa, { 0, 0, 6}},
{"m68k_op_trapge_32 ", 0xffff, 0x5cfb, { 0, 0, 8}},
{"m68k_op_trapge ", 0xffff, 0x5cfc, { 0, 0, 4}},
{"m68k_op_slt_8_pi7 ", 0xffff, 0x5ddf, { 12, 12, 10}},
{"m68k_op_slt_8_pd7 ", 0xffff, 0x5de7, { 14, 14, 11}},
{"m68k_op_slt_8_aw ", 0xffff, 0x5df8, { 16, 16, 10}},
{"m68k_op_slt_8_al ", 0xffff, 0x5df9, { 20, 20, 10}},
{"m68k_op_traplt_16 ", 0xffff, 0x5dfa, { 0, 0, 6}},
{"m68k_op_traplt_32 ", 0xffff, 0x5dfb, { 0, 0, 8}},
{"m68k_op_traplt ", 0xffff, 0x5dfc, { 0, 0, 4}},
{"m68k_op_sgt_8_pi7 ", 0xffff, 0x5edf, { 12, 12, 10}},
{"m68k_op_sgt_8_pd7 ", 0xffff, 0x5ee7, { 14, 14, 11}},
{"m68k_op_sgt_8_aw ", 0xffff, 0x5ef8, { 16, 16, 10}},
{"m68k_op_sgt_8_al ", 0xffff, 0x5ef9, { 20, 20, 10}},
{"m68k_op_trapgt_16 ", 0xffff, 0x5efa, { 0, 0, 6}},
{"m68k_op_trapgt_32 ", 0xffff, 0x5efb, { 0, 0, 8}},
{"m68k_op_trapgt ", 0xffff, 0x5efc, { 0, 0, 4}},
{"m68k_op_sle_8_pi7 ", 0xffff, 0x5fdf, { 12, 12, 10}},
{"m68k_op_sle_8_pd7 ", 0xffff, 0x5fe7, { 14, 14, 11}},
{"m68k_op_sle_8_aw ", 0xffff, 0x5ff8, { 16, 16, 10}},
{"m68k_op_sle_8_al ", 0xffff, 0x5ff9, { 20, 20, 10}},
{"m68k_op_traple_16 ", 0xffff, 0x5ffa, { 0, 0, 6}},
{"m68k_op_traple_32 ", 0xffff, 0x5ffb, { 0, 0, 8}},
{"m68k_op_traple ", 0xffff, 0x5ffc, { 0, 0, 4}},
{"m68k_op_bra_16 ", 0xffff, 0x6000, { 10, 10, 10}},
{"m68k_op_bra_32 ", 0xffff, 0x60ff, { 0, 0, 10}},
{"m68k_op_bsr_16 ", 0xffff, 0x6100, { 18, 18, 7}},
{"m68k_op_bsr_32 ", 0xffff, 0x61ff, { 0, 0, 7}},
{"m68k_op_bhi_16 ", 0xffff, 0x6200, { 10, 10, 6}},
{"m68k_op_bhi_32 ", 0xffff, 0x62ff, { 0, 0, 6}},
{"m68k_op_bls_16 ", 0xffff, 0x6300, { 10, 10, 6}},
{"m68k_op_bls_32 ", 0xffff, 0x63ff, { 0, 0, 6}},
{"m68k_op_bcc_16 ", 0xffff, 0x6400, { 10, 10, 6}},
{"m68k_op_bcc_32 ", 0xffff, 0x64ff, { 0, 0, 6}},
{"m68k_op_bcs_16 ", 0xffff, 0x6500, { 10, 10, 6}},
{"m68k_op_bcs_32 ", 0xffff, 0x65ff, { 0, 0, 6}},
{"m68k_op_bne_16 ", 0xffff, 0x6600, { 10, 10, 6}},
{"m68k_op_bne_32 ", 0xffff, 0x66ff, { 0, 0, 6}},
{"m68k_op_beq_16 ", 0xffff, 0x6700, { 10, 10, 6}},
{"m68k_op_beq_32 ", 0xffff, 0x67ff, { 0, 0, 6}},
{"m68k_op_bvc_16 ", 0xffff, 0x6800, { 10, 10, 6}},
{"m68k_op_bvc_32 ", 0xffff, 0x68ff, { 0, 0, 6}},
{"m68k_op_bvs_16 ", 0xffff, 0x6900, { 10, 10, 6}},
{"m68k_op_bvs_32 ", 0xffff, 0x69ff, { 0, 0, 6}},
{"m68k_op_bpl_16 ", 0xffff, 0x6a00, { 10, 10, 6}},
{"m68k_op_bpl_32 ", 0xffff, 0x6aff, { 0, 0, 6}},
{"m68k_op_bmi_16 ", 0xffff, 0x6b00, { 10, 10, 6}},
{"m68k_op_bmi_32 ", 0xffff, 0x6bff, { 0, 0, 6}},
{"m68k_op_bge_16 ", 0xffff, 0x6c00, { 10, 10, 6}},
{"m68k_op_bge_32 ", 0xffff, 0x6cff, { 0, 0, 6}},
{"m68k_op_blt_16 ", 0xffff, 0x6d00, { 10, 10, 6}},
{"m68k_op_blt_32 ", 0xffff, 0x6dff, { 0, 0, 6}},
{"m68k_op_bgt_16 ", 0xffff, 0x6e00, { 10, 10, 6}},
{"m68k_op_bgt_32 ", 0xffff, 0x6eff, { 0, 0, 6}},
{"m68k_op_ble_16 ", 0xffff, 0x6f00, { 10, 10, 6}},
{"m68k_op_ble_32 ", 0xffff, 0x6fff, { 0, 0, 6}},
{"m68k_op_sbcd_8_mm_axy7 ", 0xffff, 0x8f0f, { 18, 18, 16}},
{"m68k_op_pack_16_mm_axy7 ", 0xffff, 0x8f4f, { 0, 0, 13}},
{"m68k_op_unpk_16_mm_axy7 ", 0xffff, 0x8f8f, { 0, 0, 13}},
{"m68k_op_subx_8_mm_axy7 ", 0xffff, 0x9f0f, { 18, 18, 12}},
{"m68k_op_cmpm_8_axy7 ", 0xffff, 0xbf0f, { 12, 12, 9}},
{"m68k_op_abcd_8_mm_axy7 ", 0xffff, 0xcf0f, { 18, 18, 16}},
{"m68k_op_addx_8_mm_axy7 ", 0xffff, 0xdf0f, { 18, 18, 12}},
{"m68k_op_asr_16_aw ", 0xffff, 0xe0f8, { 16, 16, 9}},
{"m68k_op_asr_16_al ", 0xffff, 0xe0f9, { 20, 20, 9}},
{"m68k_op_asl_16_aw ", 0xffff, 0xe1f8, { 16, 16, 10}},
{"m68k_op_asl_16_al ", 0xffff, 0xe1f9, { 20, 20, 10}},
{"m68k_op_lsr_16_aw ", 0xffff, 0xe2f8, { 16, 16, 9}},
{"m68k_op_lsr_16_al ", 0xffff, 0xe2f9, { 20, 20, 9}},
{"m68k_op_lsl_16_aw ", 0xffff, 0xe3f8, { 16, 16, 9}},
{"m68k_op_lsl_16_al ", 0xffff, 0xe3f9, { 20, 20, 9}},
{"m68k_op_roxr_16_aw ", 0xffff, 0xe4f8, { 16, 16, 9}},
{"m68k_op_roxr_16_al ", 0xffff, 0xe4f9, { 20, 20, 9}},
{"m68k_op_roxl_16_aw ", 0xffff, 0xe5f8, { 16, 16, 9}},
{"m68k_op_roxl_16_al ", 0xffff, 0xe5f9, { 20, 20, 9}},
{"m68k_op_ror_16_aw ", 0xffff, 0xe6f8, { 16, 16, 11}},
{"m68k_op_ror_16_al ", 0xffff, 0xe6f9, { 20, 20, 11}},
{"m68k_op_rol_16_aw ", 0xffff, 0xe7f8, { 16, 16, 11}},
{"m68k_op_rol_16_al ", 0xffff, 0xe7f9, { 20, 20, 11}},
{"m68k_op_bftst_32_aw ", 0xffff, 0xe8f8, { 0, 0, 17}},
{"m68k_op_bftst_32_al ", 0xffff, 0xe8f9, { 0, 0, 17}},
{"m68k_op_bftst_32_pcdi ", 0xffff, 0xe8fa, { 0, 0, 18}},
{"m68k_op_bftst_32_pcix ", 0xffff, 0xe8fb, { 0, 0, 20}},
{"m68k_op_bfextu_32_aw ", 0xffff, 0xe9f8, { 0, 0, 19}},
{"m68k_op_bfextu_32_al ", 0xffff, 0xe9f9, { 0, 0, 19}},
{"m68k_op_bfextu_32_pcdi ", 0xffff, 0xe9fa, { 0, 0, 20}},
{"m68k_op_bfextu_32_pcix ", 0xffff, 0xe9fb, { 0, 0, 22}},
{"m68k_op_bfchg_32_aw ", 0xffff, 0xeaf8, { 0, 0, 24}},
{"m68k_op_bfchg_32_al ", 0xffff, 0xeaf9, { 0, 0, 24}},
{"m68k_op_bfexts_32_aw ", 0xffff, 0xebf8, { 0, 0, 19}},
{"m68k_op_bfexts_32_al ", 0xffff, 0xebf9, { 0, 0, 19}},
{"m68k_op_bfexts_32_pcdi ", 0xffff, 0xebfa, { 0, 0, 20}},
{"m68k_op_bfexts_32_pcix ", 0xffff, 0xebfb, { 0, 0, 22}},
{"m68k_op_bfclr_32_aw ", 0xffff, 0xecf8, { 0, 0, 24}},
{"m68k_op_bfclr_32_al ", 0xffff, 0xecf9, { 0, 0, 24}},
{"m68k_op_bfffo_32_aw ", 0xffff, 0xedf8, { 0, 0, 32}},
{"m68k_op_bfffo_32_al ", 0xffff, 0xedf9, { 0, 0, 32}},
{"m68k_op_bfffo_32_pcdi ", 0xffff, 0xedfa, { 0, 0, 33}},
{"m68k_op_bfffo_32_pcix ", 0xffff, 0xedfb, { 0, 0, 35}},
{"m68k_op_bfset_32_aw ", 0xffff, 0xeef8, { 0, 0, 24}},
{"m68k_op_bfset_32_al ", 0xffff, 0xeef9, { 0, 0, 24}},
{"m68k_op_bfins_32_aw ", 0xffff, 0xeff8, { 0, 0, 21}},
{"m68k_op_bfins_32_al ", 0xffff, 0xeff9, { 0, 0, 21}},
{"", 0, 0, {0, 0, 0}}
};
void m68ki_build_opcode_table(void);
char *m68ki_instruction_jump_table_fnname[0x10000];
int m68ki_cycles[NUM_CPU_TYPES][0x10000];
int main(int argc, char **argv) {
m68ki_build_opcode_table();
printf("#include \"m68kops.h\"\n\n");
printf("//Opcodes are built on the host, this does not need to do anything.\n");
printf("void m68ki_build_opcode_table() {}\n\n");
printf("const m68ki_instruction_jump_call m68ki_instruction_jump_table[]={\n");
for (int x=0; x<0x10000; x++) {
printf("\t%s, \n", m68ki_instruction_jump_table_fnname[x]);
}
printf("};\n\n");
printf("const unsigned char m68ki_cycles[%d][0x10000]={\n", 1);//NUM_CPU_TYPES);
// for (int x=0; x<NUM_CPU_TYPES; x++) {
for (int x=0; x<1; x++) {
printf("\t{");
for (int y=0; y<0x10000; y++) {
if ((y&15)==0) printf("\n\t\t");
printf("%d, ", m68ki_cycles[x][y]);
}
printf("\t},\n");
}
printf("};\n");
}
/* Build the opcode handler jump table */
void m68ki_build_opcode_table(void)
{
opcode_handler_struct *ostruct;
int cycle_cost;
int instr;
int i;
int j;
int k;
for(i = 0; i < 0x10000; i++)
{
/* default to illegal */
m68ki_instruction_jump_table_fnname[i] = "m68k_op_illegal";
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][i] = 0;
}
ostruct = m68k_opcode_handler_table;
while(ostruct->mask != 0xff00)
{
for(i = 0;i < 0x10000;i++)
{
if((i & ostruct->mask) == ostruct->match)
{
m68ki_instruction_jump_table_fnname[i] = ostruct->opcode_handler;
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][i] = ostruct->cycles[k];
}
}
ostruct++;
}
while(ostruct->mask == 0xff00)
{
for(i = 0;i <= 0xff;i++)
{
m68ki_instruction_jump_table_fnname[ostruct->match | i] = ostruct->opcode_handler;
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][ostruct->match | i] = ostruct->cycles[k];
}
ostruct++;
}
while(ostruct->mask == 0xf1f8)
{
for(i = 0;i < 8;i++)
{
for(j = 0;j < 8;j++)
{
instr = ostruct->match | (i << 9) | j;
m68ki_instruction_jump_table_fnname[instr] = ostruct->opcode_handler;
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][instr] = ostruct->cycles[k];
// For all shift operations with known shift distance (encoded in instruction word)
if((instr & 0xf000) == 0xe000 && (!(instr & 0x20)))
{
// On the 68000 and 68010 shift distance affect execution time.
// Add the cycle cost of shifting; 2 times the shift distance
cycle_cost = ((((i-1)&7)+1)<<1);
m68ki_cycles[0][instr] += cycle_cost;
m68ki_cycles[1][instr] += cycle_cost;
// On the 68020 shift distance does not affect execution time
m68ki_cycles[2][instr] += 0;
}
}
}
ostruct++;
}
while(ostruct->mask == 0xfff0)
{
for(i = 0;i <= 0x0f;i++)
{
m68ki_instruction_jump_table_fnname[ostruct->match | i] = ostruct->opcode_handler;
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][ostruct->match | i] = ostruct->cycles[k];
}
ostruct++;
}
while(ostruct->mask == 0xf1ff)
{
for(i = 0;i <= 0x07;i++)
{
m68ki_instruction_jump_table_fnname[ostruct->match | (i << 9)] = ostruct->opcode_handler;
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][ostruct->match | (i << 9)] = ostruct->cycles[k];
}
ostruct++;
}
while(ostruct->mask == 0xfff8)
{
for(i = 0;i <= 0x07;i++)
{
m68ki_instruction_jump_table_fnname[ostruct->match | i] = ostruct->opcode_handler;
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][ostruct->match | i] = ostruct->cycles[k];
}
ostruct++;
}
while(ostruct->mask == 0xffff)
{
m68ki_instruction_jump_table_fnname[ostruct->match] = ostruct->opcode_handler;
for(k=0;k<NUM_CPU_TYPES;k++)
m68ki_cycles[k][ostruct->match] = ostruct->cycles[k];
ostruct++;
}
}
/* ======================================================================== */
/* ============================== END OF FILE ============================= */
/* ======================================================================== */
|
the_stack_data/79954.c | /*
* Copyright (c) 2020 SparkFun Electronics
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#if DEVICE_SPI
#include "spi_api.h"
#include "iom_api.h"
#include "PeripheralPins.h"
#include "mbed_assert.h"
#include <string.h>
#define DEFAULT_CLK_FREQ (4000000)
#define DEFAULT_SPI_MODE (AM_HAL_IOM_SPI_MODE_0)
static am_hal_iom_transfer_t xfer = {0};
SPIName spi_get_peripheral_name(PinName mosi, PinName miso, PinName sclk)
{
uint32_t iom_mosi = pinmap_peripheral(mosi, spi_master_mosi_pinmap());
uint32_t iom_miso = pinmap_peripheral(miso, spi_master_miso_pinmap());
uint32_t iom_sclk = pinmap_peripheral(sclk, spi_master_clk_pinmap());
uint32_t iom;
if (miso == NC) {
iom = pinmap_merge(iom_mosi, iom_sclk);
} else if (mosi == NC) {
iom = pinmap_merge(iom_miso, iom_sclk);
} else {
uint32_t iom_data = pinmap_merge(iom_mosi, iom_miso);
iom = pinmap_merge(iom_data, iom_sclk);
}
if ((int)iom == NC) {
return IOM_NUM;
}
return (SPIName)iom;
}
void spi_get_capabilities(PinName ssel, bool slave, spi_capabilities_t *cap)
{
MBED_ASSERT(cap);
SPIName iom_ssel = (SPIName)pinmap_peripheral(ssel, spi_master_cs_pinmap());
cap->minimum_frequency = 0;
cap->maximum_frequency = AM_HAL_IOM_MAX_FREQ;
cap->word_length = 0x00000080;
cap->slave_delay_between_symbols_ns = 0;
cap->clk_modes = 0x0F;
cap->support_slave_mode = (iom_ssel == IOM_ANY) ? true : false;
cap->hw_cs_handle = false;
cap->async_mode = false;
cap->tx_rx_buffers_equal_length = false;
}
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
{
MBED_ASSERT(obj);
MBED_ASSERT((int)ssel == NC);
// iom determination
SPIName iom = spi_get_peripheral_name(mosi, miso, sclk);
MBED_ASSERT((int)iom != IOM_NUM);
MBED_ASSERT((int)iom != IOM_ANY);
// iom configuration
obj->spi.iom_obj.iom.inst = (uint32_t)iom;
obj->spi.iom_obj.iom.cfg.eInterfaceMode = AM_HAL_IOM_SPI_MODE;
obj->spi.iom_obj.iom.cfg.ui32ClockFreq = DEFAULT_CLK_FREQ;
obj->spi.iom_obj.iom.cfg.eSpiMode = DEFAULT_SPI_MODE;
obj->spi.iom_obj.iom.cfg.pNBTxnBuf = NULL;
obj->spi.iom_obj.iom.cfg.ui32NBTxnBufLength = 0;
// invariant xfer settings
xfer.ui32InstrLen = 0;
xfer.ui32Instr = 0;
xfer.bContinue = false;
xfer.ui8RepeatCount = 0;
xfer.ui8Priority = 1;
xfer.ui32PauseCondition = 0;
xfer.ui32StatusSetClr = 0;
// pin configuration
pinmap_config(sclk, spi_master_clk_pinmap());
if ((int)mosi != NC) {
pinmap_config(mosi, spi_master_mosi_pinmap());
}
if ((int)miso != NC) {
pinmap_config(miso, spi_master_miso_pinmap());
}
if ((int)ssel != NC) {
pinmap_config(ssel, spi_master_cs_pinmap());
}
// initialization
iom_init(&obj->spi.iom_obj);
}
void spi_free(spi_t *obj)
{
iom_deinit(&obj->spi.iom_obj);
}
void spi_format(spi_t *obj, int bits, int mode, int slave)
{
MBED_ASSERT(obj);
obj->spi.iom_obj.iom.cfg.eSpiMode = (am_hal_iom_spi_mode_e)mode;
iom_init(&obj->spi.iom_obj);
}
void spi_frequency(spi_t *obj, int hz)
{
MBED_ASSERT(obj);
obj->spi.iom_obj.iom.cfg.ui32ClockFreq = (uint32_t)hz;
iom_init(&obj->spi.iom_obj);
}
int spi_master_write(spi_t *obj, int value)
{
uint32_t rxval = 0;
spi_master_block_write(obj, (const char *)&value, 1, (char *)&rxval, 1, SPI_FILL_CHAR);
return rxval;
}
int spi_master_block_write(spi_t *obj, const char *tx_buffer, int tx_length, char *rx_buffer, int rx_length, char write_fill)
{
MBED_ASSERT(obj);
int chars_handled = 0;
uint32_t status = AM_HAL_STATUS_SUCCESS;
// always perform a duplex xfer
xfer.eDirection = AM_HAL_IOM_FULLDUPLEX;
if (tx_length == rx_length) {
xfer.pui32RxBuffer = (uint32_t *)rx_buffer;
xfer.pui32TxBuffer = (uint32_t *)tx_buffer;
xfer.ui32NumBytes = tx_length;
status = am_hal_iom_spi_blocking_fullduplex(obj->spi.iom_obj.iom.handle, &xfer);
}
// handle difference between buffers
else if (tx_length < rx_length) {
xfer.pui32RxBuffer = (uint32_t *)rx_buffer;
xfer.ui32NumBytes = rx_length - tx_length;
uint8_t fill[xfer.ui32NumBytes];
memset(fill, write_fill, xfer.ui32NumBytes);
xfer.pui32TxBuffer = (uint32_t *)&fill;
status = am_hal_iom_spi_blocking_fullduplex(obj->spi.iom_obj.iom.handle, &xfer);
}
else {
xfer.pui32TxBuffer = (uint32_t *)tx_buffer;
xfer.ui32NumBytes = tx_length - rx_length;
uint8_t fill[xfer.ui32NumBytes];
memset(fill, write_fill, xfer.ui32NumBytes);
xfer.pui32RxBuffer = (uint32_t *)&fill;
status = am_hal_iom_spi_blocking_fullduplex(obj->spi.iom_obj.iom.handle, &xfer);
}
if (AM_HAL_STATUS_SUCCESS != status) {
return 0;
}
chars_handled += xfer.ui32NumBytes;
return chars_handled;
}
int spi_slave_receive(spi_t *obj)
{
MBED_ASSERT(0);
return 0;
}
int spi_slave_read(spi_t *obj)
{
MBED_ASSERT(0);
return 0;
}
void spi_slave_write(spi_t *obj, int value)
{
MBED_ASSERT(0);
}
int spi_busy(spi_t *obj)
{
MBED_ASSERT(0);
return 0;
}
const PinMap *spi_master_mosi_pinmap()
{
return PinMap_SPI_MOSI;
}
const PinMap *spi_master_miso_pinmap()
{
return PinMap_SPI_MISO;
}
const PinMap *spi_master_clk_pinmap()
{
return PinMap_SPI_SCLK;
}
const PinMap *spi_master_cs_pinmap()
{
return PinMap_SPI_SSEL;
}
const PinMap *spi_slave_mosi_pinmap()
{
return PinMap_SPI_MOSI;
}
const PinMap *spi_slave_miso_pinmap()
{
return PinMap_SPI_MISO;
}
const PinMap *spi_slave_clk_pinmap()
{
return PinMap_SPI_SCLK;
}
const PinMap *spi_slave_cs_pinmap()
{
return PinMap_SPI_SSEL;
}
#endif // DEVICE_SPI
|
the_stack_data/159516773.c | int PARTITION(int *arr, int p, int r) //把子数组原址排序，并返回中间值q
{
int x = *(arr+r);
int i = p-1;
int j = p;
int temp;
for(; j <= r-1; j++)
{
if (arr[j] <= x)
{
++i;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
temp = arr[i+1];
arr[i+1] = arr[r];
arr[r] = temp;
return i+1;
}
void QUICKSORT(int *arr, int p, int r)
{
int q;
if (p < r)
{
q = PARTITION(arr, p, r);
QUICKSORT(arr, p, q-1);
QUICKSORT(arr, q+1, r);
}
}
int main()
{
int arr[8] = {18,21,13,4,58,6,47,8};
QUICKSORT(arr, 0, 7);
}
|
the_stack_data/76942.c | int test() {
double x = 2;
x /= 3;
int false1 = 0.2 > x;
int true1 = 0.3 < x;
int true2 = 0.3 != 3.2;
return
(
true1 &&
true2 &&
false1 == 0) ? 0 : 1;
}
|
the_stack_data/7949333.c | // +build ignore
char __license[] __attribute__((section("license"), used)) = "MIT";
__attribute__((section("socket"), used)) int filter() {
return 0;
}
|
the_stack_data/117539.c | #include <stdio.h>
#include <stdlib.h>
struct Queue
{
unsigned int capacity;
int front, rear;
int *arr;
};
struct Queue *createQueue(int); // basic queue operation using array
void enQueue(struct Queue *, int); // basic queue operation using array
int deQueue(struct Queue *); // basic queue operation using array
int peek(struct Queue *); // basic queue operation using array
int isFull(struct Queue *); // basic queue operation using array
int isEmpty(struct Queue *); // basic queue operation using array
void clear(struct Queue *); // basic queue operation using array
void display(struct Queue *);
int main()
{
struct Queue *q = createQueue(5);
printf("is empty = %d\n", isEmpty(q));
enQueue(q, 10);
enQueue(q, 20);
printf("is full = %d\n", isFull(q));
enQueue(q, 30);
enQueue(q, 40);
printf("is empty = %d\n", isEmpty(q));
enQueue(q, 50);
display(q);
printf("is full = %d\n", isFull(q));
deQueue(q);
deQueue(q);
display(q);
printf("rear = %d and front = %d\n", q->front, q->rear);
clear(q);
return 0;
}
struct Queue *createQueue(int capacity)
{
struct Queue *q = (struct Queue *)malloc(sizeof(struct Queue));
q->capacity = capacity;
q->front = q->rear = -1;
q->arr = (int *)malloc(capacity * sizeof(int));
return q;
}
void enQueue(struct Queue *q, int value)
{
if (!isFull(q))
{
if (isEmpty(q))
{
q->front = q->rear = 0;
q->arr[q->rear] = value;
}
else
q->arr[++q->rear] = value;
}
}
int deQueue(struct Queue *queue)
{
if (!isEmpty(queue))
{
return queue->arr[queue->front++];
}
return -999;
}
int peek(struct Queue *queue)
{
if (!isEmpty(queue))
return queue->arr[queue->rear];
return -999;
}
int isFull(struct Queue *queue)
{
if (queue->rear == queue->capacity - 1)
return 1;
return 0;
}
int isEmpty(struct Queue *queue)
{
if ((queue->front == -1) || (queue->front > queue->rear))
return 1;
return 0;
}
void clear(struct Queue *queue)
{
free(queue->arr);
free(queue);
}
void display(struct Queue *queue)
{
printf("====================================\n");
printf("%16s\n", "Displaying Queue");
int i = queue->front;
for (; i <= queue->rear; i++)
printf("%d ", queue->arr[i]);
printf("\n====================================\n");
} |
the_stack_data/210992.c | #include <stdlib.h>
typedef struct ln {
int data;
struct ln* next;
} SLL;
SLL* listAppend(SLL* x, int v) {
if (x == NULL) {
SLL* el = malloc(sizeof(SLL));
el->data = v;
el->next = NULL;
return el;
} else {
SLL* tailp = listAppend(x->next, v);
x->next = tailp;
return x;
};
}
SLL* listPrepend(SLL* x, int v) {
SLL* new_node = malloc(sizeof(SLL));
new_node->data = v;
new_node->next = x;
return new_node;
}
int listLength(SLL* x) {
if (x == NULL) {
return 0;
} else {
return 1 + listLength(x->next);
};
}
void listDispose(SLL* x) {
if (x == NULL) {
return;
} else {
listDispose(x->next);
free(x);
return;
};
}
SLL* listCopy(SLL* x) {
SLL* r;
if (x == NULL) {
r = NULL;
} else {
SLL* t = listCopy(x->next);
r = malloc(sizeof(SLL));
r->data = x->data;
r->next = t;
};
return r;
}
SLL* listConcat(SLL* x, SLL* y) {
SLL* r;
if (x == NULL) {
r = y;
} else {
SLL* c = listConcat (x->next, y);
x->next = c;
r = x;
};
return r;
}
int sum(SLL* x) {
if (x == NULL) {
return 0;
} else {
return x->data + sum(x->next);
}
}
int altern(SLL* x) {
if (x == NULL) {
return 0;
} else {
return x->data - altern(x->next);
}
}
int main() {
SLL* x = NULL;
x = listAppend(x, 3);
x = listAppend(x, 4);
x = listAppend(x, 5);
x = listPrepend(x, 2);
x = listPrepend(x, 1);
SLL* y = listCopy(x);
x = listConcat(x, y);
int shouldBeTrue = ((sum(x) == 30) + (altern(x) == 0) + (listLength(x) == 10)) == 3;
return !shouldBeTrue; /* returns 3 */
} |
the_stack_data/40762706.c |
#include <stdio.h>
void scilab_rt_contour_d2i2d2d0d0d0s0d2i2d0_(int in00, int in01, double matrixin0[in00][in01],
int in10, int in11, int matrixin1[in10][in11],
int in20, int in21, double matrixin2[in20][in21],
double scalarin0,
double scalarin1,
double scalarin2,
char* scalarin3,
int in30, int in31, double matrixin3[in30][in31],
int in40, int in41, int matrixin4[in40][in41],
double scalarin4)
{
int i;
int j;
double val0 = 0;
int val1 = 0;
double val2 = 0;
double val3 = 0;
int val4 = 0;
for (i = 0; i < in00; ++i) {
for (j = 0; j < in01; ++j) {
val0 += matrixin0[i][j];
}
}
printf("%f", val0);
for (i = 0; i < in10; ++i) {
for (j = 0; j < in11; ++j) {
val1 += matrixin1[i][j];
}
}
printf("%d", val1);
for (i = 0; i < in20; ++i) {
for (j = 0; j < in21; ++j) {
val2 += matrixin2[i][j];
}
}
printf("%f", val2);
printf("%f", scalarin0);
printf("%f", scalarin1);
printf("%f", scalarin2);
printf("%s", scalarin3);
for (i = 0; i < in30; ++i) {
for (j = 0; j < in31; ++j) {
val3 += matrixin3[i][j];
}
}
printf("%f", val3);
for (i = 0; i < in40; ++i) {
for (j = 0; j < in41; ++j) {
val4 += matrixin4[i][j];
}
}
printf("%d", val4);
printf("%f", scalarin4);
}
|
the_stack_data/39446.c | #include <stdio.h>
#include <stdlib.h>
int main(){
int i, j;
system("cls");
for(i=1;i<=7;i++){
for(j=1;j<=7;j++){
if(i == j){
printf("\\");
}else if(i == 8-j){
printf("/");
}else{
printf("*");
}
}
printf("\n");
}
return 0;
} |
the_stack_data/59511627.c |
typedef enum { false, true } bool;
int main(void)
{
bool b1, b2, b3;
b1 = true;
b2 = false;
b3 = b1 ^ b2;
return 0;
}
|
the_stack_data/154827996.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <math.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <signal.h>
#include <errno.h>
#include <arpa/inet.h>
#define SQR(a) ((sqrarg=(a)) == 0.0 ? 0.0 : sqrarg*sqrarg)
//Structures
struct
{
int satid;
double wstart;
double wstop;
int chan;
} satpasses[1000];
struct
{
int satfmnum;
double dyear;
int month;
int day;
int hour;
int min;
int sec;
long satorbitnum;
float meananom;
char station [3];
float azimuth;
float elevation;
float range;
int satchannel;
int fftbincenter;
float bin1[8];
float bin2[8];
float bin3[8];
float bin4[8];
float noisebin1[10];
float noisebin2[10];
float noisebin3[10];
float noisebin4[10];
float tot1;
float tot2;
float tot3;
float tot4;
} aq;
struct
{
int weight[901];
float ratio1[901];
float ratio2[901];
} mapAzimuth[3601];
//Round to the nearest 1/10 degree.
//Function Prototypes
int read_passinfo(void);
int read_satpower(void);
int write_data(void);
int write_noise_data(void);
int write_map12(void);
int write_map34(void);
//Global Variables
int totsatpassid;
float channel1, channel2, channel3, channel4;
int azIndex, elIndex;
//Files
char passfilename[60];
char satpowerfilename[60];
//char *listname="listpowerfiles_Z02";
//char *listname="listpowerfiles_20degE";
//char *listname="listpowerfiles_Null1";
char *listname;//="listpowerfiles_Null2";
char runningfile[35];
char includepassdata[60];
char noisefile[60];
char *mapfile12="mapfile12";
char *mapfile34="mapfile34";
FILE *passfile;
FILE *satpowerfile;
FILE *fp1;
FILE *pass;
FILE *noise;
FILE *map12;
FILE *map34;
//********************************************************
int main(int argc, char *argv[])
{
int listmax;
int filecycles;
if (argc != 2){
printf( "usage: %s listfilename\n", argv[0] );
exit(1);
}
listname = argv[1];
printf("opening acqnamefile: '%s'\n",listname);
if ((fp1=fopen(listname,"r"))==NULL)
{
printf("Cannot open acqname file. \n");
exit(1);
}
fscanf(fp1,"%i",&listmax);
fscanf(fp1,"%s",passfilename);
fscanf(fp1,"%s", includepassdata);
fscanf(fp1,"%s", noisefile);
printf("Reading pass file %s ...\n",passfilename);
read_passinfo();
for (filecycles=0; filecycles<listmax; filecycles++)
{
fscanf(fp1,"%s",satpowerfilename);
printf("Reading sat power file %s ...\n", satpowerfilename);
read_satpower();
}
// printf("Writing map12 file ...\n");
// write_map12();
// printf("Writing map34 file ...\n");
// write_map34();
// fclose(fp1);
printf("End of Program\n");
return 0;
}
//********************************************************
int read_passinfo()
{
int i=0;
if ((passfile=fopen(passfilename,"r"))==NULL)
{
printf("Cannot open pass file. \n");
exit(1);
}
while (feof(passfile)==0)
{
i++;
fscanf(passfile, "%d %lf %lf %d \n", &satpasses[i].satid, &satpasses[i].wstart, &satpasses[i].wstop, &satpasses[i].chan);
}
totsatpassid=i;
// printf("There are %d entries. \n", i);
fclose(passfile);
return 0;
}
//********************************************************
int read_satpower()
{
int i, j, k, b, n;
int acqnum;
char acqstr[12];
char timemark[3];
char dayofweek[3];
char strmonth[3];
int date;
int hour;
int minute;
int second;
int year;
float fftbin1[515], fftbin2[515], fftbin3[515], fftbin4[515];
char tmp1[8], tmp2[10], tmp3[10], tmp4[10], tmp5[10], tmp6[10], tmp7[10], tmp8[10], tmp9[10];
double dyear;
int month=0, mlen=0, maccum=0;
int centerbin;
int fftcenterbinsofvisiblesats[20];
float temp1,temp2,temp3,temp4;
int visiblesatnum;
struct
{
char satname[10];
int satnum;
float azimuth;
float elevation;
float range;
float velocity;
float meananom;
long orbitnum;
} satinfo[10];
if ((satpowerfile=fopen(satpowerfilename,"r"))==NULL)
{
printf("Cannot open sat power file. \n");
exit(1);
}
while (feof(satpowerfile)==0)
{
fscanf(satpowerfile, "%s%d",acqstr, &acqnum);
fscanf(satpowerfile, "%s%s%s%d%d:%d:%d%d", timemark, dayofweek, strmonth, &date, &hour, &minute, &second, &year);
if (strcmp(strmonth, "Jan")==0) { month=1; mlen=31; maccum=0;}
else if (strcmp(strmonth, "Feb")==0){month=2; mlen=28; maccum=31;}
else if (strcmp(strmonth, "Mar")==0){month=3; mlen=31; maccum=59;}
else if (strcmp(strmonth, "Apr")==0){month=4; mlen=30; maccum=90;}
else if (strcmp(strmonth, "May")==0){month=5; mlen=31; maccum=120;}
else if (strcmp(strmonth, "Jun")==0){month=6; mlen=30; maccum=151;}
else if (strcmp(strmonth, "Jul")==0){month=7; mlen=31; maccum=181;}
else if (strcmp(strmonth, "Aug")==0){month=8; mlen=31; maccum=212;}
else if (strcmp(strmonth, "Sep")==0){month=9; mlen=30; maccum=243;}
else if (strcmp(strmonth, "Oct")==0){month=10;mlen=31; maccum=273;}
else if (strcmp(strmonth, "Nov")==0){month=11;mlen=30; maccum=304;}
else if (strcmp(strmonth, "Dec")==0){month=12;mlen=31; maccum=334;}
else
{
printf("No option selected.");
}
dyear=year+ ((double)maccum + (double)date + ((double)hour+(double)minute/60+(double)second/3600)/24)/365;
i=1;
fscanf(satpowerfile, "%s", satinfo[i].satname);
while (strcmp(satinfo[i].satname, "Bin")!=0)
{
//printf("reading sat num from string: '%s'\n",satinfo[i].satname);
char stuff[256];
int david;
sprintf(stuff,"%s",satinfo[i].satname);
printf("stuff: %s\n",stuff);
sscanf(stuff, "FM%d",&david);
satinfo[i].satnum = david;
printf("david: %d\tsatinfo[i].satnum = %d\n",david,satinfo[i].satnum);
//sscanf(stuff, "FM%d",&satinfo[i].satnum);
//printf("satnum: %d\n",&satinfo[i].satnum);
fscanf(satpowerfile, "%f%f%f%f%f%ld", &satinfo[i].azimuth, &satinfo[i].elevation, &satinfo[i].range, &satinfo[i].velocity, &satinfo[i].meananom, &satinfo[i].orbitnum);
i++;
fscanf(satpowerfile, "%s", satinfo[i].satname);
}
// printf("Reading junk ...\n");
fscanf(satpowerfile,"%s\n %s %s %s %s %s %s %s %s\n", tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
aq.tot1=0; aq.tot2=0; aq.tot3=0; aq.tot4=0;
for (b=1; b<513; b++)
{
fscanf(satpowerfile, "%f %f %f %f", &fftbin1[b], &fftbin2[b], &fftbin3[b], &fftbin4[b]);
aq.tot1 += fftbin1[b]*fftbin1[b];
aq.tot2 += fftbin2[b]*fftbin2[b];
aq.tot3 += fftbin3[b]*fftbin3[b];
aq.tot4 += fftbin4[b]*fftbin4[b];
}
// prepare data for storage
// printf("Preparing data storage ...\n");
aq.dyear=dyear;
aq.month = month;
aq.day = date;
aq.hour = hour;
aq.min = minute;
aq.sec = second;
for (j=1; j<(totsatpassid+1); j++){ // for all sats
for (k=1; k<i; k++){ // for all passes
// check if the current time is between the pass start and end time
if ((dyear>satpasses[j].wstart) && (dyear< satpasses[j].wstop) && (satpasses[j].satid==satinfo[k].satnum)){
aq.satfmnum=satinfo[k].satnum;
aq.satorbitnum=satinfo[k].orbitnum;
aq.meananom=satinfo[k].meananom;
sprintf(aq.station, "GB");
aq.azimuth=satinfo[k].azimuth;
aq.elevation=satinfo[k].elevation;
aq.range=satinfo[k].range;
aq.satchannel=satpasses[j].chan;
centerbin = (int)((float) aq.satchannel*2.5*512/1000);
aq.fftbincenter=centerbin;
aq.bin1[1]=fftbin1[centerbin-3];
aq.bin1[2]=fftbin1[centerbin-2];
aq.bin1[3]=fftbin1[centerbin-1];
aq.bin1[4]=fftbin1[centerbin];
aq.bin1[5]=fftbin1[centerbin+1];
aq.bin1[6]=fftbin1[centerbin+2];
aq.bin1[7]=fftbin1[centerbin+3];
aq.bin2[1]=fftbin2[centerbin-3];
aq.bin2[2]=fftbin2[centerbin-2];
aq.bin2[3]=fftbin2[centerbin-1];
aq.bin2[4]=fftbin2[centerbin];
aq.bin2[5]=fftbin2[centerbin+1];
aq.bin2[6]=fftbin2[centerbin+2];
aq.bin2[7]=fftbin2[centerbin+3];
aq.bin3[1]=fftbin3[centerbin-3];
aq.bin3[2]=fftbin3[centerbin-2];
aq.bin3[3]=fftbin3[centerbin-1];
aq.bin3[4]=fftbin3[centerbin];
aq.bin3[5]=fftbin3[centerbin+1];
aq.bin3[6]=fftbin3[centerbin+2];
aq.bin3[7]=fftbin3[centerbin+3];
aq.bin4[1]=fftbin4[centerbin-3];
aq.bin4[2]=fftbin4[centerbin-2];
aq.bin4[3]=fftbin4[centerbin-1];
aq.bin4[4]=fftbin4[centerbin];
aq.bin4[5]=fftbin4[centerbin+1];
aq.bin4[6]=fftbin4[centerbin+2];
aq.bin4[7]=fftbin4[centerbin+3];
write_data();
channel1=0;
channel2=0;
channel3=0;
channel4=0;
for (n=1; n<8; n++) channel1=channel1+aq.bin1[n];
for (n=1; n<8; n++) channel2=channel2+aq.bin2[n];
for (n=1; n<8; n++) channel3=channel3+aq.bin3[n];
for (n=1; n<8; n++) channel4=channel4+aq.bin4[n];
azIndex=(int) rintf(10*aq.azimuth);
elIndex=(int) rintf(10*aq.elevation);
//printf("%d %d\n", azIndex, elIndex);
mapAzimuth[azIndex].ratio1[elIndex]=(channel1*channel1/(50*2))/(channel2*channel2/(50*2));
mapAzimuth[azIndex].ratio2[elIndex]=(channel3*channel3/(50*2))/(channel4*channel4/(50*2));
// printf("Processing satellite %d \n", satinfo[k].satnum);
}
}
}
}
fclose(satpowerfile);
return 0;
}
//********************************************************
int write_data()
{
sprintf(runningfile, "%s%d", includepassdata, aq.satfmnum);
//printf("filename is %s \n", runningfile);
if ((pass=fopen(runningfile,"a"))==NULL)
{
printf("Cannot open include pass file.\n" );
exit(1);
}
fprintf(pass, "%02d/%02d/%4d %02d:%02d:%02d %2d %4.12f %8ld %3.2f %3s %3.3f %3.3f %4.2f %3d %3d %2.6f %2.6f %2.6f %2.6f\n %.6f %.6f %.6f %.6f %.6f %.6f %.6f\n %.6f %.6f %.6f %.6f %.6f %.6f %.6f\n %.6f %.6f %.6f %.6f %.6f %.6f %.6f\n %.6f %.6f %.6f %.6f %.6f %.6f %.6f\n",aq.month,aq.day,(int)floor(aq.dyear),aq.hour,aq.min,aq.sec,aq.satfmnum, aq.dyear, aq.satorbitnum, aq.meananom, aq.station, aq.azimuth, aq.elevation, aq.range, aq.satchannel, aq.fftbincenter, aq.tot1,aq.tot2,aq.tot3,aq.tot4, aq.bin1[1],aq.bin1[2],aq.bin1[3],aq.bin1[4],aq.bin1[5],aq.bin1[6],aq.bin1[7], aq.bin2[1],aq.bin2[2],aq.bin2[3],aq.bin2[4],aq.bin2[5],aq.bin2[6],aq.bin2[7],aq.bin3[1],aq.bin3[2],aq.bin3[3],aq.bin3[4],aq.bin3[5],aq.bin3[6],aq.bin3[7], aq.bin4[1],aq.bin4[2],aq.bin4[3],aq.bin4[4],aq.bin4[5],aq.bin4[6],aq.bin4[7]);
fclose(pass);
return 0;
}
|
the_stack_data/25137618.c | #ifndef TH_GENERIC_FILE
#define TH_GENERIC_FILE "generic/TemporalUpSamplingNearest.c"
#else
static inline void THNN_(TemporalUpSamplingNearest_shapeCheck)
(THTensor *input, THTensor *gradOutput,
int scale_factor) {
THArgCheck(input != NULL, 2, "3D input tensor expected but got NULL");
THArgCheck(scale_factor > 1, 4,
"scale_factor must be greater than 1, but got: %d", scale_factor);
THNN_ARGCHECK(input->nDimension == 2 || input->nDimension == 3, 2, input,
"2D or 3D input tensor expected but got: %s");
if (input->nDimension == 2) {
int nChannels = THTensor_(size)(input, 0);
int inputWidth = THTensor_(size)(input, 1);
int outputWidth = inputWidth * scale_factor;
if (gradOutput != NULL) {
THNN_CHECK_DIM_SIZE(gradOutput, 3, 0, nChannels);
THNN_CHECK_DIM_SIZE(gradOutput, 3, 1, outputWidth);
}
} else {
int nBatch = THTensor_(size)(input, 0);
int nChannels = THTensor_(size)(input, 1);
int inputWidth = THTensor_(size)(input, 2);
int outputWidth = inputWidth * scale_factor;
if (gradOutput != NULL) {
THNN_CHECK_DIM_SIZE(gradOutput, 3, 0, nBatch);
THNN_CHECK_DIM_SIZE(gradOutput, 3, 1, nChannels);
THNN_CHECK_DIM_SIZE(gradOutput, 3, 2, outputWidth);
}
}
}
void THNN_(TemporalUpSamplingNearest_updateOutput)(
THNNState *state,
THTensor *input,
THTensor *output,
int scale_factor)
{
THNN_(TemporalUpSamplingNearest_shapeCheck)(input, NULL, scale_factor);
int inputWidth = THTensor_(size)(input, input->nDimension-1);
int outputWidth = inputWidth * scale_factor;
if (input->nDimension == 2) {
THTensor_(resize2d)(output,
THTensor_(size)(input, 0),
outputWidth);
} else {
THTensor_(resize3d)(output,
THTensor_(size)(input, 0),
THTensor_(size)(input, 1),
outputWidth);
}
int dW = scale_factor;
int xDim = input->nDimension-1;
// dims
int idim = input->nDimension;
int osz0 = output->size[0];
int osz1 = output->size[1];
int osz2 = 1;
if (idim > 2) {
osz2 = output->size[2];
}
// get strides
int64_t *is = input->stride;
int64_t *os = output->stride;
// get raw pointers
real *pin = THTensor_(data)(input);
real *pout = THTensor_(data)(output);
// perform the upsampling
int i0, i1, i2, isrc, idst;
int iout[3]; // Output indices
int iin[3]; // Input indices
for (i0 = 0; i0 < osz0; i0++) {
iout[0] = i0;
iin[0] = i0;
for (i1 = 0; i1 < osz1; i1++) {
iout[1] = i1;
iin[1] = i1;
for (i2 = 0; i2 < osz2; i2++) {
iout[2] = i2;
iin[2] = i2;
// set the indices for the upsampled dimensions
iin[xDim] = iout[xDim] / dW;
idst = i0*os[0] + i1*os[1];
isrc = iin[0]*is[0] + iin[1]*is[1];
if (idim > 2) {
idst += i2*os[2];
isrc += iin[2]*is[2];
}
pout[idst] = pin[isrc];
}
}
}
}
void THNN_(TemporalUpSamplingNearest_updateGradInput)(
THNNState *state,
THTensor *input,
THTensor *gradOutput,
THTensor *gradInput,
int scale_factor)
{
THNN_(TemporalUpSamplingNearest_shapeCheck)(input, gradOutput, scale_factor);
THTensor_(resizeAs)(gradInput, input);
int dW = scale_factor;
int xDim = gradInput->nDimension-1;
// dims
int idim = gradInput->nDimension; // Guaranteed to be between 2 and 4
int isz0 = gradInput->size[0];
int isz1 = gradInput->size[1];
int isz2 = 1;
if (idim > 2) {
isz2 = gradInput->size[2];
}
// get strides
int64_t *is = gradInput->stride;
int64_t *os = gradOutput->stride;
// get raw pointers
real *pin = THTensor_(data)(gradInput);
real *pout = THTensor_(data)(gradOutput);
// perform the upsampling
int i0, i1, i2, isrc, idst, x, y;
int iin[3]; // Input indices
int iout[3]; // Output indices
THTensor_(zero)(gradInput);
for (i0 = 0; i0 < isz0; i0++) {
iin[0] = i0;
iout[0] = i0;
for (i1 = 0; i1 < isz1; i1++) {
iin[1] = i1;
iout[1] = i1;
for (i2 = 0; i2 < isz2; i2++) {
iin[2] = i2;
iout[2] = i2;
idst = i0*is[0] + i1*is[1];
if (idim > 2) {
idst += i2*is[2];
}
// Now accumulate the gradients from gradOutput
for (x = 0; x < dW; x++) {
iout[xDim] = dW * iin[xDim] + x;
isrc = iout[0]*os[0] + iout[1]*os[1];
if (idim > 2) {
isrc += iout[2]*os[2];
}
pin[idst] += pout[isrc];
}
}
}
}
}
#endif
|
the_stack_data/31386478.c | // Minimum test in "C" that passes.
#include <stdlib.h>
int main(void)
{
exit(0);
}
|
the_stack_data/27682.c | #include <stdio.h>
int sum_n(int n) {
return n*(n+1)/2;
}
int main() {
int n;
scanf("%i", &n);
printf("%i", sum_n(n));
}
|
the_stack_data/108475.c | #include <stdio.h>
#include <stdlib.h>
struct ListNode
{
int val;
struct ListNode *next;
};
int detectLoop(struct ListNode *list1)
{
struct ListNode *S = list1, *F = list1;
while (S && F && F->next)
{
S = S->next;
F = F->next->next;
if (F == S)
return 1;
}
return 0;
}
int main()
{
struct ListNode *head = malloc(sizeof(struct ListNode));
head->val = 5;
struct ListNode *l1 = malloc(sizeof(struct ListNode));
l1->val = 10;
head->next = l1;
struct ListNode *l2 = malloc(sizeof(struct ListNode));
l2->val = 20;
l1->next = l2;
struct ListNode *l3 = malloc(sizeof(struct ListNode));
l3->val = 30;
l2->next = l3;
struct ListNode *l4 = malloc(sizeof(struct ListNode));
l4->val = 40;
l3->next = l4;
l4->next = l1;
struct ListNode *l5 = malloc(sizeof(struct ListNode));
l5->val = 50;
// 5 -> 10-> 20 50
// ↑ |
// | ↓
// 40 <- 30
if (detectLoop(head))
printf("\n\nLoop is present in the linked list.\n\n");
else
printf("\n\nLoop is not present in the linked list\n\n");
return 0;
}
|
the_stack_data/86075402.c | #include <stdio.h>
#include <openssl/bn.h>
void printBN(char *msg, BIGNUM * a);
int main()
{
BN_CTX *ctx = BN_CTX_new();
BIGNUM *e = BN_new();
BIGNUM *n = BN_new();
BIGNUM *signature = BN_new();
BIGNUM *msg = BN_new();
// Vhma 2 e
BN_hex2bn(&e, "10001");
// Vhma 2 n
BN_hex2bn(&n, "C5760F0FD943293B6C6DD147ADDE10BF23C278A84A7735F1235BE04C1E41E7C23100BD88374575DDB90210801E8FED64230445A7A0393B814DCF633FC249FF229E88B0D296B95C8A741F922A2AF212C8B76854B55841814068061A4F8529FBB54D3C0F4F3F40961BCEA8CC5E35FF6498F575DD745405A036110412245563EF94772E77F11576EED3A45945219FA8BED127ED0AE8AB38CA3F87D1DAF18FB90B1F44E7E0ADF395C2164DEC84A33A92D4CFC67DE6BDCB1A404FB354B1F38F6F0D1EE3BE49A356E407BC8DA7CE1DB05B5756D1C41CFC9865D1CD462F9194BF458549F86D52871C0256012716AB722EF471E461B520A0FA26696A0AF1AB9F6DB7CF25");
// Vhma 3 signature.txt
BN_hex2bn(&signature, "7e8ecc2e0d4cfee069e686d37aff5b9669fbf348ec6bd255b0f111d2d09b61e39d473c877eeb539de84e966a29f5674f4031458a26a43d7ae4c9c9edadd619b4389be4acada8c3541468ed6687c0825b73e37a721a97443e90cec7e2f02989b0f43bf5ccc5f38c5866f9e342911f2599145856ed7ae7407ec1b341809a2e0ba57963fcc9235ad42112f569ee9efe94a14aa99b72ded690666adc37fccee679db87b473ebaaebe2253c31cca06c4748fcc47520055be26d50364a7d82c84ca3e1fc5f0fdf63507b5269085fa362e2127e411bc86feea9dafc738118aa1109e58e6099176a63e7b343442755f2f9bbc584af6bf0f3c651859c982ddf45ec81b9c6");
// msg = signature ^ e mod n
BN_mod_exp(msg, signature, e, n, ctx);
// Ektypwsh apotelesmatwn
printBN("msg = ", msg);
}
void printBN(char *msg, BIGNUM * a)
{
char * number_str = BN_bn2hex(a);
printf("%s%s\n", msg, number_str);
OPENSSL_free(number_str);
} |
the_stack_data/184517487.c | // C program to find a Pair with Given Sum using Hash
#include <stdio.h>
#include <stdlib.h>
#define MAX 10000
void findPairs(int *arr, int size, int sum)
{
int index, temp;
int hash[MAX] = {0};
for(index = 0; index < size; index++)
{
temp = sum - arr[index];
if(temp >= 0 && hash[temp] == 1)
printf("Pair with given sum %d is (%d, %d)\n", sum, arr[index], temp);
hash[arr[index]] = 1;
}
}
int main()
{
int size, index, sum, *arr;
printf("Enter number of Elements in an array \n");
scanf("%d", &size);
//allocate memory for array
arr = (int *) malloc(sizeof(int) * size);
printf("Enter elements to array\n");
for(index = 0; index < size; index++)
scanf("%d", &arr[index]);
printf("Enter sum value");
scanf("%d", &sum);
findPairs(arr, size, sum);
return 0;
} |
the_stack_data/25136590.c | /* Copyright (c) 2021 Intel Corporation
* Copyright (c) 2020-2021 Alibaba Cloud
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
static double current_time()
{
struct timeval tv;
gettimeofday(&tv, NULL);
return (double)(1000000 * tv.tv_sec + tv.tv_usec) / 1000000.0;
}
void ocall_print_string(const char *str)
{
/* Proxy/Bridge will check the length and null-terminate
* the input string to prevent buffer overflow.
*/
printf("%s", str);
}
void ocall_current_time(double *time)
{
if (!time)
return;
*time = current_time();
return;
}
void ocall_low_res_time(int *time)
{
if (!time)
return;
struct timeval tv;
*time = tv.tv_sec;
}
|
the_stack_data/147971.c | /* This testcase is part of GDB, the GNU debugger.
Copyright 2008-2021 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/>. */
/*
Test file to be compiled with -fstack-check, for testing "bt" against
different stack checking prologue sequences.
*/
int i = 0;
void
small_frame ()
{
i++; /* set breakpoint here */
}
void medium_frame ()
{
char S [16384];
small_frame ();
}
void big_frame ()
{
char S [524188];
small_frame ();
}
int
main ()
{
small_frame ();
medium_frame ();
big_frame ();
return 0;
}
|
the_stack_data/568597.c | #include <utmpx.h>
#include <stddef.h>
struct utmpx * pututxline(const struct utmpx *utmpx)
{
return NULL;
}
/*
XOPEN(400)
*/
|
the_stack_data/153268702.c | #include <stdio.h>
#include <pthread.h>
volatile int global = 0;
void *compute(void *arg)
{
int i;
for(i = 0; i < 100 * 100 * 100; i++)
{
global++;
}
return NULL;
}
int main()
{
int i;
pthread_t tids[3];
global = 0;
for(i = 0; i < 3; i++)
pthread_create(&tids[i], NULL, compute, NULL);
for(i = 0; i < 3; i++)
pthread_join(tids[i], NULL);
printf("global = %d\n", global);
return 0;
}
|
the_stack_data/20450974.c | // This is an include statement. More information about this will follow.
#include <stdio.h>
// Our main function.
int main()
{
// An integer to store the result
int c;
// It is probably guessable what this will do.
printf("What is 1+1? ");
/**
* Ask the user for input. The %d indicates that we want an integer.
* The & sign may look strange, but for now you just have to remember
* it. We will get to that in a later exercise.
*/
scanf(" %d", &c);
// The following piece should be quite easy to follow. A detailed explanation will follow.
if (c == 2)
{
printf("Good, that is correct. You must be very smart.\n");
}
else
{
printf("Really? Please consider kindergarten before attempting to learn C.\n");
}
// You can leave this return statement out.
return 0;
} |
the_stack_data/248581275.c | int x;
int y = 42;
void foo() {
x=0x1234;
for (int i = 0; i < x; i++);
}
void _start() {
foo();
while(y);
}
|
the_stack_data/117329147.c | /* ====================================================================
* Copyright (c) 1989-2000 Carnegie Mellon University. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The names "Sphinx" and "Carnegie Mellon" must not be used to
* endorse or promote products derived from this software without
* prior written permission. To obtain permission, contact
* [email protected].
*
* 4. Products derived from this software may not be called "Sphinx"
* nor may "Sphinx" appear in their names without prior written
* permission of Carnegie Mellon University. To obtain permission,
* contact [email protected].
*
* 5. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by Carnegie
* Mellon University (http://www.speech.cs.cmu.edu/)."
*
* THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS'' AND
* ANY EXPRESSED 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 CARNEGIE MELLON UNIVERSITY
* NOR ITS EMPLOYEES 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.
*
* ====================================================================
*
*/
/*
* longword I/O routines
*
* Created October 11, 1989 by Joe Keane.
*
* These routines read and write longwords in a machine-independent format:
* four bytes, most significant first. On the Sun this is the same as the
* internal format, so these routines can use fread and fwrite. The routines
* return negative result on error, except for read_long, where the caller
* has to check for errors.
*/
#include <stdio.h>
long read_long (FILE *stream)
{
int c;
long word;
c = getc (stream);
if (c == EOF)
return -1;
word = c;
c = getc (stream);
if (c == EOF)
return -1;
word = word << 8 | c;
c = getc (stream);
if (c == EOF)
return -1;
word = word << 8 | c;
c = getc (stream);
if (c == EOF)
return -1;
return word << 8 | c;
}
int write_long (FILE *stream, long word)
{
if (putc (word >> 24, stream) == EOF)
return -1;
if (putc (word >> 16, stream) == EOF)
return -1;
if (putc (word >> 8, stream) == EOF)
return -1;
if (putc (word, stream) == EOF)
return -1;
return 0;
}
int read_long_array (FILE *stream, long *base, int length)
{
#ifdef sun
return fread ((char *) base, length * 4, 1, stream) != 1 ? -1 : 0;
#else
int counter;
long *ptr;
counter = length;
ptr = base;
while (--counter >= 0)
{
int c;
long word;
c = getc (stream);
if (c == EOF)
return -1;
word = c;
c = getc (stream);
if (c == EOF)
return -1;
word = word << 8 | c;
c = getc (stream);
if (c == EOF)
return -1;
word = word << 8 | c;
c = getc (stream);
if (c == EOF)
return -1;
*ptr++ = word << 8 | c;
}
return 0;
#endif
}
int write_long_array (FILE *stream, long *base, int length)
{
#ifdef sun
return fwrite((char *) base, length * 4, 1, stream) != 1 ? -1 : 0;
#else
int counter;
long *ptr;
counter = length;
ptr = base;
while (--counter >= 0)
{
long word;
word = *ptr++;
if (putc (word >> 24, stream) == EOF)
return -1;
if (putc (word >> 16, stream) == EOF)
return -1;
if (putc (word >> 8, stream) == EOF)
return -1;
if (putc (word, stream) == EOF)
return -1;
}
return 0;
#endif
}
|
the_stack_data/165769470.c | #include <stdio.h>
int main()
{
int a,b,c,d;
b=343;
for(a=1;a<=4;a++)
{
c= b%10;
d=b/10;
a=a+c+d;
}
printf("%d",a);
return 0;
}
//o/p
//39
|
the_stack_data/851776.c |
#include <stdio.h>
#include <unistd.h>
#include <dirent.h>
int main()
{
DIR *dir_info;
struct dirent *dir_entry;
mkdir( "test_A" , 0755);
mkdir( "test_B" , 0755);
dir_info = opendir( ".");
if ( NULL != dir_info)
{
while( dir_entry = readdir( dir_info))
{
printf( "%s\n", dir_entry->d_name);
}
closedir( dir_info);
}
} |
the_stack_data/1032786.c |
/*Write a C program that reads the names (as character strings of length upto 20 bytes) and corresponsing roll-numbers (as integers) of 10 students from the user and stores them in a file whose name is specified by the user-
in text format
in binary format
After running the program check the size of the file created using ls -l command. Also see the content of the binary file using the command
od -c filename. */
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct student
{
char rollnum[15];
char Name[20];
};
int main()
{
int i;
// int n;
char roll[10],name[10];
char textfile[10],binfile[10];
// char tempfile[10];
printf("Enter Name of text file: ");
scanf("%s",textfile);
strcat(textfile,".txt");
printf("Enter Name of the binary file: ");
scanf("%s",binfile);
strcat(binfile,".bin");
FILE *fp1,*fp2;
fp1=fopen(textfile,"w");
fp2=fopen(binfile,"wb");
char ch;
struct student stu;
printf("Binary Mode\n");
printf("Enter name & Roll No of 10 students: ");
for(i=0;i<10;i++)
{
printf("\n");
printf("For student %d : \n",i+1);
printf("Enter Name: ");
scanf("%s",stu.Name);
printf("Enter roll No of %s : \n",stu.Name);
scanf("%s",stu.rollnum);
fwrite(&stu,sizeof(stu),1,fp2);
}
printf("Text Mode ");
for(i=0;i<10;i++)
{
printf("\n");
printf("For student %d : \n",i+1);
printf("Enter Name: ");
scanf("%s",name);
printf("Enter roll No of %s : \n",name);
scanf("%s",roll);
fprintf(fp1,"%s\t%s\n",name,roll);
}
fclose(fp1);
fclose(fp2);
return 0;
for(i=0;i<10;i++)
{
printf("\n");
printf("For student %d : \n",i+1);
printf("Enter Name: ");
scanf("%s",stu.Name);
printf("Enter roll No of %s : \n",name);
scanf("%s",stu.rollnum);
fprintf(fp1,"%s\t%s\n",name,roll);
fwrite(&stu,sizeof(stu),1,fp2);
}
}
|
the_stack_data/26700434.c | /*numPass=0, numTotal=5
Verdict:WRONG_ANSWER, Visibility:1, Input:"12345", ExpOutput:"Reverse of 12345 is 54321", Output:""
Verdict:WRONG_ANSWER, Visibility:1, Input:"1331", ExpOutput:"Reverse of 1331 is 1331", Output:""
Verdict:WRONG_ANSWER, Visibility:1, Input:"100", ExpOutput:"Reverse of 100 is 1", Output:""
Verdict:WRONG_ANSWER, Visibility:0, Input:"0", ExpOutput:"Reverse of 0 is 0", Output:""
Verdict:WRONG_ANSWER, Visibility:0, Input:"10", ExpOutput:"Reverse of 10 is 1", Output:""
*/
#include<stdio.h>
int main()
{
int n,rev = 0;
scanf("%d",&n);
while(n>0) {
rev = (rev*10);
rev = rev + n%10;
n = n/10;
}
return 0;
} |
the_stack_data/524648.c | #include <stdio.h>
#include <stdlib.h>
#include <errno.h>
unsigned int checkIsPrime(unsigned int test)
{
unsigned int i,rem,isPrime;
isPrime = 1;
for(i=2;i < test ;i++)
{
rem = test % i;
if(rem == 0U)
{
isPrime = 0;
}
}
return(isPrime);
}
int main(int argc, char *argv[])
{
unsigned int integer = 0,i;
char *eptr= NULL;
unsigned long long convResult = 0U;
printf("Program name: %s\n", __BASE_FILE__);
if(argc > 1)
{
convResult = strtoll(argv[1], (char ** __restrict__ )eptr, 10);
if(convResult == 0U)
{
exit(0);
}
integer = convResult;
if(integer < 2)
{
printf("The number is %d", integer);
return 0;
}
for(i=2; i <= integer; i++)
{
if(checkIsPrime(i))
{
printf(":%d:",i);
}
}
putchar('\n');
}else
{
printf("Usage...\n");
}
return 0;
} |
the_stack_data/284901.c | /*
* 函数：
* 能够完成特定功能的独立的代码单元（逻辑上）
* 能够接受数据，对接收的数据进行处理，返回处理结果（物理上）
*
* 总结： 函数是一个工具， 它是为了解决大量类似问题而设计的
* 函数可以当作一个黑匣子(提供功能，无需展现逻辑
*
* 例子：
* 求两个数字，最大数
*
* 函数功能：
* 逻辑复用
* 程序模块化
*
* c语言基本单位： 函数
*
*
* 函数分类：
* 1. 有参/无参函数
* 2. 有返回值/无返回值函数
* 3. 库函数 和用户自定义函数
* 4. 普通函数 和主函数
* 5. 值传递函数 和 地址传递函数(严格来说不存在）
*
* 一个程序必须有且仅有一个主函数
* 普通函数不可以调用主函数 主函数可以调用普通函数
* 普通函数可以相互调用
* 主函数是程序的入口，也是程序的出口。
*
*
*/
#include <stdio.h>
// 声明函数max, void 表示函数无返回值。 i， j 函数形式参数
// 实现比较
void max(int i , int j)
{
if (i > j)
printf("%d\n", i);
else
printf("%d\n", j);
}
int main(void) // 括号中的void表示函数不接收参数, int 表示函数返回数据类型。
{
int a, b, c, d, e, f;
a = 1, b = 2, c = 3, d = 9, e = -5, f = 100;
max(a, b);
max(c, d);
max(e, f);
return 0;
}
|
the_stack_data/225144314.c | #include <stdio.h>
#include <stdlib.h>
typedef struct D {
int cnt;
char c;
}f;
int cmp(const void* c, const void *d) {
f *a = (f*) c, *b = (f*) d;
if (a->cnt == b->cnt) return a->c - b->c;
else return b->cnt - a->cnt;
}
int main() {
f cnt[26] = { 0 };
char t;
for (int i = 0; i < 26; i++) cnt[i].c = i + 'a';
while ((t = getchar()) != EOF) if (t != ' ' || t != 10) cnt[t - 'a'].cnt++;
qsort(cnt, 26, sizeof(f), cmp);
for (int i = 0; cnt[0].cnt == cnt[i].cnt; i++) putchar(cnt[i].c);
} |
the_stack_data/145422.c | #include <stdio.h>
int main() {
int num, i, count = 0;
for (i = 1; i <= 5; i++){
scanf("%d", &num);
if (num%2==0){
count += 1;
}
}
printf("%d valores pares\n", count);
return 0;
} |
the_stack_data/24859.c | #include <stdlib.h>
extern int __VERIFIER_nondet_int(void);
/*-
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
void *
cmemchr(const void *s, int c, size_t n)
{
if (n != 0) {
const unsigned char *p = s;
do {
if (*p++ == (unsigned char)c)
return ((void *)(p - 1));
} while (--n != 0);
}
return (NULL);
}
int main() {
int length = __VERIFIER_nondet_int();
int n = __VERIFIER_nondet_int();
int c = __VERIFIER_nondet_int();
if (length < 1) {
length = 1;
}
if (n < 1) {
n = 1;
}
char* nondetArea = (char*) alloca(n * sizeof(char));
cmemchr(nondetArea, c, n);
return 0;
}
|
the_stack_data/132952815.c | #ifdef CS333_P2
#include "types.h"
#include "user.h"
#include "uproc.h"
int
main(int argc, char * argv[])
{
int max = 72;
if(argc > 1)
max = atoi(argv[1]);
struct uproc * table = malloc(sizeof(*table)*max);
if(table == 0)
{
printf(1, "Unable to initialize table in ps.c\n");
exit();
}
int process = getprocs(max, table);
int time;
int decim;
int cpuTime;
int cpuDecim;
if(process < 1)
{
free(table);
printf(1, "Error\n");
}
#ifdef CS333_P3P4
printf(1, "PID\tName\tUID\tGID\tPPID\tPrio\tElapsed\tCPU\tState\tSize\n");
#else
printf(1, "PID\tName\tUID\tGID\tPPID\tElapsed\tCPU\tState\tSize\n");
#endif
for(int i = 0; i < process; i++)
{
printf(1, "%d\t%s\t%d\t%d\t%d\t",
table[i].pid,
table[i].name,
table[i].uid,
table[i].gid,
table[i].ppid);
#ifdef CS333_P3P4
printf(1, "%d\t", table[i].prio);
#endif
time = table[i].elapsed_ticks;
decim = time % 1000;
time /= 1000;
if(decim < 10)
printf(1, "%d.00%d\t", time, decim);
else if(decim < 100 && decim >= 10)
printf(1, "%d.0%d\t", time, decim);
else
printf(1, "%d.%d\t", time, decim);
cpuTime = table[i].CPU_total_ticks;
cpuDecim = cpuTime % 1000;
cpuTime /= 1000;
if(cpuDecim < 10)
printf(1, "%d.00%d\t", cpuTime, cpuDecim);
else if(cpuDecim < 100 && cpuDecim >= 10)
printf(1, "%d.0%d\t", cpuTime, cpuDecim);
else
printf(1, "%d.%d\t", cpuTime, cpuDecim);
printf(1, "%s\t", table[i].state);
printf(1, "%d\n", table[i].size);
}
free(table);
exit();
}
#endif
|
the_stack_data/734852.c | #include <stdio.h>
char *strncpy(char *s, const char *ct, int n);
char *strncat(char *s, const char *ct, int n);
int strncmp(const char *cs, const char *ct, int n);
main()
{
char s[100];
printf("%s\n", strncpy(s, "hola que tal", 7));
printf("%s\n", strncat(s, "parece que no se copio todo", 13));
printf("%d\n", strncmp(s, "hola quparece que si", 18));
printf("%d\n", strncmp(s, "hola quparece que si", 100));
return 0;
}
char *strncpy(char *s, const char *ct, int n)
{
/* I dont want to pad with '\0' :P */
char *os = s;
for ( ; (*s = *ct) && n; s++, ct++, n--)
;
*s = '\0';
return os;
}
char *strncat(char *s, const char *ct, int n)
{
char *os = s;
for ( ; *s; ++s)
;
for ( ; (*s = *ct) && n; ++s, ++ct, --n)
;
*s = '\0';
return os;
}
int strncmp(const char *cs, const char *ct, int n)
{
for ( ; --n && *cs == *ct; cs++, ct++)
if (*cs == '\0')
return 0;
return *cs - *ct;
}
|
the_stack_data/74411.c | /* This file was automatically generated by CasADi.
The CasADi copyright holders make no ownership claim of its contents. */
#ifdef __cplusplus
extern "C" {
#endif
/* How to prefix internal symbols */
#ifdef CODEGEN_PREFIX
#define NAMESPACE_CONCAT(NS, ID) _NAMESPACE_CONCAT(NS, ID)
#define _NAMESPACE_CONCAT(NS, ID) NS ## ID
#define CASADI_PREFIX(ID) NAMESPACE_CONCAT(CODEGEN_PREFIX, ID)
#else
#define CASADI_PREFIX(ID) wt_nx6p2_get_matrices_fun_ ## ID
#endif
#include <math.h>
#ifndef casadi_real
#define casadi_real double
#endif
#ifndef casadi_int
#define casadi_int int
#endif
/* Add prefix to internal symbols */
#define casadi_f0 CASADI_PREFIX(f0)
#define casadi_s0 CASADI_PREFIX(s0)
#define casadi_s1 CASADI_PREFIX(s1)
#define casadi_s2 CASADI_PREFIX(s2)
#define casadi_s3 CASADI_PREFIX(s3)
#define casadi_s4 CASADI_PREFIX(s4)
#define casadi_s5 CASADI_PREFIX(s5)
#define casadi_s6 CASADI_PREFIX(s6)
#define casadi_s7 CASADI_PREFIX(s7)
/* Symbol visibility in DLLs */
#ifndef CASADI_SYMBOL_EXPORT
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#if defined(STATIC_LINKED)
#define CASADI_SYMBOL_EXPORT
#else
#define CASADI_SYMBOL_EXPORT __declspec(dllexport)
#endif
#elif defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#define CASADI_SYMBOL_EXPORT __attribute__ ((visibility ("default")))
#else
#define CASADI_SYMBOL_EXPORT
#endif
#endif
static const casadi_int casadi_s0[5] = {1, 1, 0, 1, 0};
static const casadi_int casadi_s1[75] = {8, 8, 0, 8, 16, 24, 32, 40, 48, 56, 64, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7};
static const casadi_int casadi_s2[21] = {8, 2, 0, 8, 16, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7};
static const casadi_int casadi_s3[12] = {8, 1, 0, 8, 0, 1, 2, 3, 4, 5, 6, 7};
static const casadi_int casadi_s4[51] = {5, 8, 0, 5, 10, 15, 20, 25, 30, 35, 40, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4};
static const casadi_int casadi_s5[3] = {5, 0, 0};
static const casadi_int casadi_s6[5] = {0, 2, 0, 0, 0};
static const casadi_int casadi_s7[3] = {0, 0, 0};
/* wt_nx6p2_get_matrices_fun:(i0)->(o0[8x8],o1[8x2],o2[8],o3[8x8],o4[5x8],o5[5x8],o6[5x0],o7[0x2],o8[],o9[8],o10[]) */
static int casadi_f0(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem) {
casadi_real a0, a1, a2;
a0=0.;
if (res[0]!=0) res[0][0]=a0;
if (res[0]!=0) res[0][1]=a0;
a1=1.;
if (res[0]!=0) res[0][2]=a1;
if (res[0]!=0) res[0][3]=a0;
if (res[0]!=0) res[0][4]=a0;
if (res[0]!=0) res[0][5]=a0;
if (res[0]!=0) res[0][6]=a0;
if (res[0]!=0) res[0][7]=a0;
a2=1.5311917180143535e+00;
if (res[0]!=0) res[0][8]=a2;
if (res[0]!=0) res[0][9]=a0;
if (res[0]!=0) res[0][10]=a0;
if (res[0]!=0) res[0][11]=a1;
if (res[0]!=0) res[0][12]=a0;
if (res[0]!=0) res[0][13]=a0;
if (res[0]!=0) res[0][14]=a0;
if (res[0]!=0) res[0][15]=a0;
if (res[0]!=0) res[0][16]=a0;
if (res[0]!=0) res[0][17]=a0;
if (res[0]!=0) res[0][18]=a0;
if (res[0]!=0) res[0][19]=a0;
if (res[0]!=0) res[0][20]=a0;
if (res[0]!=0) res[0][21]=a0;
if (res[0]!=0) res[0][22]=a0;
if (res[0]!=0) res[0][23]=a0;
a2=2.1376003035282697e+01;
if (res[0]!=0) res[0][24]=a2;
if (res[0]!=0) res[0][25]=a0;
if (res[0]!=0) res[0][26]=a0;
if (res[0]!=0) res[0][27]=a0;
if (res[0]!=0) res[0][28]=a0;
if (res[0]!=0) res[0][29]=a0;
if (res[0]!=0) res[0][30]=a0;
if (res[0]!=0) res[0][31]=a0;
if (res[0]!=0) res[0][32]=a0;
if (res[0]!=0) res[0][33]=a0;
if (res[0]!=0) res[0][34]=a0;
if (res[0]!=0) res[0][35]=a0;
a2=-2.5000000000000000e+00;
if (res[0]!=0) res[0][36]=a2;
if (res[0]!=0) res[0][37]=a0;
if (res[0]!=0) res[0][38]=a0;
if (res[0]!=0) res[0][39]=a0;
a2=-2.3897923837070362e-02;
if (res[0]!=0) res[0][40]=a2;
if (res[0]!=0) res[0][41]=a0;
if (res[0]!=0) res[0][42]=a0;
if (res[0]!=0) res[0][43]=a0;
if (res[0]!=0) res[0][44]=a0;
a2=-50.;
if (res[0]!=0) res[0][45]=a2;
if (res[0]!=0) res[0][46]=a0;
if (res[0]!=0) res[0][47]=a0;
if (res[0]!=0) res[0][48]=a0;
if (res[0]!=0) res[0][49]=a0;
if (res[0]!=0) res[0][50]=a0;
if (res[0]!=0) res[0][51]=a0;
a2=2.5000000000000000e+00;
if (res[0]!=0) res[0][52]=a2;
if (res[0]!=0) res[0][53]=a0;
if (res[0]!=0) res[0][54]=a0;
if (res[0]!=0) res[0][55]=a0;
if (res[0]!=0) res[0][56]=a0;
if (res[0]!=0) res[0][57]=a0;
if (res[0]!=0) res[0][58]=a0;
if (res[0]!=0) res[0][59]=a0;
if (res[0]!=0) res[0][60]=a0;
a2=50.;
if (res[0]!=0) res[0][61]=a2;
if (res[0]!=0) res[0][62]=a0;
if (res[0]!=0) res[0][63]=a0;
if (res[1]!=0) res[1][0]=a0;
if (res[1]!=0) res[1][1]=a0;
if (res[1]!=0) res[1][2]=a0;
if (res[1]!=0) res[1][3]=a0;
if (res[1]!=0) res[1][4]=a0;
if (res[1]!=0) res[1][5]=a0;
if (res[1]!=0) res[1][6]=a1;
if (res[1]!=0) res[1][7]=a0;
if (res[1]!=0) res[1][8]=a0;
if (res[1]!=0) res[1][9]=a0;
if (res[1]!=0) res[1][10]=a0;
if (res[1]!=0) res[1][11]=a0;
if (res[1]!=0) res[1][12]=a0;
if (res[1]!=0) res[1][13]=a0;
if (res[1]!=0) res[1][14]=a0;
if (res[1]!=0) res[1][15]=a1;
if (res[2]!=0) res[2][0]=a0;
if (res[2]!=0) res[2][1]=a1;
if (res[2]!=0) res[2][2]=a0;
if (res[2]!=0) res[2][3]=a0;
if (res[2]!=0) res[2][4]=a0;
if (res[2]!=0) res[2][5]=a0;
if (res[2]!=0) res[2][6]=a0;
if (res[2]!=0) res[2][7]=a0;
if (res[3]!=0) res[3][0]=a1;
if (res[3]!=0) res[3][1]=a0;
if (res[3]!=0) res[3][2]=a0;
if (res[3]!=0) res[3][3]=a0;
if (res[3]!=0) res[3][4]=a0;
if (res[3]!=0) res[3][5]=a0;
if (res[3]!=0) res[3][6]=a0;
if (res[3]!=0) res[3][7]=a0;
if (res[3]!=0) res[3][8]=a0;
if (res[3]!=0) res[3][9]=a1;
if (res[3]!=0) res[3][10]=a0;
if (res[3]!=0) res[3][11]=a0;
if (res[3]!=0) res[3][12]=a0;
if (res[3]!=0) res[3][13]=a0;
if (res[3]!=0) res[3][14]=a0;
if (res[3]!=0) res[3][15]=a0;
if (res[3]!=0) res[3][16]=a0;
if (res[3]!=0) res[3][17]=a0;
if (res[3]!=0) res[3][18]=a1;
if (res[3]!=0) res[3][19]=a0;
if (res[3]!=0) res[3][20]=a0;
if (res[3]!=0) res[3][21]=a0;
if (res[3]!=0) res[3][22]=a0;
if (res[3]!=0) res[3][23]=a0;
if (res[3]!=0) res[3][24]=a0;
if (res[3]!=0) res[3][25]=a0;
if (res[3]!=0) res[3][26]=a0;
if (res[3]!=0) res[3][27]=a1;
if (res[3]!=0) res[3][28]=a0;
if (res[3]!=0) res[3][29]=a0;
if (res[3]!=0) res[3][30]=a0;
if (res[3]!=0) res[3][31]=a0;
if (res[3]!=0) res[3][32]=a0;
if (res[3]!=0) res[3][33]=a0;
if (res[3]!=0) res[3][34]=a0;
if (res[3]!=0) res[3][35]=a0;
if (res[3]!=0) res[3][36]=a1;
if (res[3]!=0) res[3][37]=a0;
if (res[3]!=0) res[3][38]=a0;
if (res[3]!=0) res[3][39]=a0;
if (res[3]!=0) res[3][40]=a0;
if (res[3]!=0) res[3][41]=a0;
if (res[3]!=0) res[3][42]=a0;
if (res[3]!=0) res[3][43]=a0;
if (res[3]!=0) res[3][44]=a0;
if (res[3]!=0) res[3][45]=a1;
if (res[3]!=0) res[3][46]=a0;
if (res[3]!=0) res[3][47]=a0;
if (res[3]!=0) res[3][48]=a0;
if (res[3]!=0) res[3][49]=a0;
if (res[3]!=0) res[3][50]=a0;
if (res[3]!=0) res[3][51]=a0;
if (res[3]!=0) res[3][52]=a0;
if (res[3]!=0) res[3][53]=a0;
if (res[3]!=0) res[3][54]=a1;
if (res[3]!=0) res[3][55]=a0;
if (res[3]!=0) res[3][56]=a0;
if (res[3]!=0) res[3][57]=a0;
if (res[3]!=0) res[3][58]=a0;
if (res[3]!=0) res[3][59]=a0;
if (res[3]!=0) res[3][60]=a0;
if (res[3]!=0) res[3][61]=a0;
if (res[3]!=0) res[3][62]=a0;
if (res[3]!=0) res[3][63]=a1;
if (res[4]!=0) res[4][0]=a1;
if (res[4]!=0) res[4][1]=a0;
if (res[4]!=0) res[4][2]=a0;
if (res[4]!=0) res[4][3]=a0;
if (res[4]!=0) res[4][4]=a0;
if (res[4]!=0) res[4][5]=a0;
if (res[4]!=0) res[4][6]=a1;
if (res[4]!=0) res[4][7]=a0;
if (res[4]!=0) res[4][8]=a0;
if (res[4]!=0) res[4][9]=a0;
if (res[4]!=0) res[4][10]=a0;
if (res[4]!=0) res[4][11]=a0;
if (res[4]!=0) res[4][12]=a1;
if (res[4]!=0) res[4][13]=a0;
if (res[4]!=0) res[4][14]=a0;
if (res[4]!=0) res[4][15]=a0;
if (res[4]!=0) res[4][16]=a0;
if (res[4]!=0) res[4][17]=a0;
if (res[4]!=0) res[4][18]=a1;
if (res[4]!=0) res[4][19]=a0;
if (res[4]!=0) res[4][20]=a0;
if (res[4]!=0) res[4][21]=a0;
if (res[4]!=0) res[4][22]=a0;
if (res[4]!=0) res[4][23]=a0;
if (res[4]!=0) res[4][24]=a1;
if (res[4]!=0) res[4][25]=a0;
if (res[4]!=0) res[4][26]=a0;
if (res[4]!=0) res[4][27]=a0;
if (res[4]!=0) res[4][28]=a0;
if (res[4]!=0) res[4][29]=a0;
if (res[4]!=0) res[4][30]=a0;
if (res[4]!=0) res[4][31]=a0;
if (res[4]!=0) res[4][32]=a0;
if (res[4]!=0) res[4][33]=a0;
if (res[4]!=0) res[4][34]=a0;
if (res[4]!=0) res[4][35]=a0;
if (res[4]!=0) res[4][36]=a0;
if (res[4]!=0) res[4][37]=a0;
if (res[4]!=0) res[4][38]=a0;
if (res[4]!=0) res[4][39]=a0;
if (res[5]!=0) res[5][0]=a0;
if (res[5]!=0) res[5][1]=a0;
if (res[5]!=0) res[5][2]=a0;
if (res[5]!=0) res[5][3]=a0;
if (res[5]!=0) res[5][4]=a0;
if (res[5]!=0) res[5][5]=a0;
if (res[5]!=0) res[5][6]=a0;
if (res[5]!=0) res[5][7]=a0;
if (res[5]!=0) res[5][8]=a0;
if (res[5]!=0) res[5][9]=a0;
if (res[5]!=0) res[5][10]=a0;
if (res[5]!=0) res[5][11]=a0;
if (res[5]!=0) res[5][12]=a0;
if (res[5]!=0) res[5][13]=a0;
if (res[5]!=0) res[5][14]=a0;
if (res[5]!=0) res[5][15]=a0;
if (res[5]!=0) res[5][16]=a0;
if (res[5]!=0) res[5][17]=a0;
if (res[5]!=0) res[5][18]=a0;
if (res[5]!=0) res[5][19]=a0;
if (res[5]!=0) res[5][20]=a0;
if (res[5]!=0) res[5][21]=a0;
if (res[5]!=0) res[5][22]=a0;
if (res[5]!=0) res[5][23]=a0;
if (res[5]!=0) res[5][24]=a0;
if (res[5]!=0) res[5][25]=a0;
if (res[5]!=0) res[5][26]=a0;
if (res[5]!=0) res[5][27]=a0;
if (res[5]!=0) res[5][28]=a0;
if (res[5]!=0) res[5][29]=a0;
if (res[5]!=0) res[5][30]=a0;
if (res[5]!=0) res[5][31]=a0;
if (res[5]!=0) res[5][32]=a0;
if (res[5]!=0) res[5][33]=a0;
if (res[5]!=0) res[5][34]=a0;
if (res[5]!=0) res[5][35]=a0;
if (res[5]!=0) res[5][36]=a0;
if (res[5]!=0) res[5][37]=a0;
if (res[5]!=0) res[5][38]=a0;
if (res[5]!=0) res[5][39]=a0;
if (res[9]!=0) res[9][0]=a0;
if (res[9]!=0) res[9][1]=a0;
if (res[9]!=0) res[9][2]=a0;
if (res[9]!=0) res[9][3]=a0;
if (res[9]!=0) res[9][4]=a0;
if (res[9]!=0) res[9][5]=a0;
if (res[9]!=0) res[9][6]=a0;
if (res[9]!=0) res[9][7]=a0;
return 0;
}
CASADI_SYMBOL_EXPORT int wt_nx6p2_get_matrices_fun(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem){
return casadi_f0(arg, res, iw, w, mem);
}
CASADI_SYMBOL_EXPORT void wt_nx6p2_get_matrices_fun_incref(void) {
}
CASADI_SYMBOL_EXPORT void wt_nx6p2_get_matrices_fun_decref(void) {
}
CASADI_SYMBOL_EXPORT casadi_int wt_nx6p2_get_matrices_fun_n_in(void) { return 1;}
CASADI_SYMBOL_EXPORT casadi_int wt_nx6p2_get_matrices_fun_n_out(void) { return 11;}
CASADI_SYMBOL_EXPORT const char* wt_nx6p2_get_matrices_fun_name_in(casadi_int i){
switch (i) {
case 0: return "i0";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const char* wt_nx6p2_get_matrices_fun_name_out(casadi_int i){
switch (i) {
case 0: return "o0";
case 1: return "o1";
case 2: return "o2";
case 3: return "o3";
case 4: return "o4";
case 5: return "o5";
case 6: return "o6";
case 7: return "o7";
case 8: return "o8";
case 9: return "o9";
case 10: return "o10";
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* wt_nx6p2_get_matrices_fun_sparsity_in(casadi_int i) {
switch (i) {
case 0: return casadi_s0;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT const casadi_int* wt_nx6p2_get_matrices_fun_sparsity_out(casadi_int i) {
switch (i) {
case 0: return casadi_s1;
case 1: return casadi_s2;
case 2: return casadi_s3;
case 3: return casadi_s1;
case 4: return casadi_s4;
case 5: return casadi_s4;
case 6: return casadi_s5;
case 7: return casadi_s6;
case 8: return casadi_s7;
case 9: return casadi_s3;
case 10: return casadi_s7;
default: return 0;
}
}
CASADI_SYMBOL_EXPORT int wt_nx6p2_get_matrices_fun_work(casadi_int *sz_arg, casadi_int* sz_res, casadi_int *sz_iw, casadi_int *sz_w) {
if (sz_arg) *sz_arg = 1;
if (sz_res) *sz_res = 11;
if (sz_iw) *sz_iw = 0;
if (sz_w) *sz_w = 0;
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
|
the_stack_data/179830554.c | int removeDuplicates(int* nums, int numsSize) {
if (numsSize == 0) return 0;
int i = 1;
for (int j = 1; j != numsSize; ++j)
if (nums[j - 1] != nums[j]) nums[i++] = nums[j];
return i;
}
|
the_stack_data/53357.c | /**************************************************************************
Author : Rohit Kumar | [email protected] | https://rohitkumar.ml
Domain : C language (HackerRank)
Programs : Printing Pattern Using Loops
URL : https://www.hackerrank.com/challenges/printing-pattern-2/problem
**************************************************************************/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main()
{
int n;
scanf("%d", &n);
int l=2*n-1;
int p,i,j;
for(i=0;i<l;i++)
{
for(j=0;j<l;j++)
{
p=i<j? i:j;
p=p<l-i?p:l-i-1;
p=p<l-j-1?p:l-j-1;
printf("%d ",n-p);
}
printf("\n");
}
return 0;
}
/**************************************************************************/
|
the_stack_data/575988.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
{
float x1, y1, x2, y2, Distancia;
printf ("Digite a primeira coordenada do 1 ponto: \n");
scanf ("%f", &x1);
printf ("Digite a segunda coordenada do 1 ponto: \n");
scanf ("%f", &y1);
printf ("Digite a primeira coordenada do 2 ponto: \n");
scanf ("%f", &x2);
printf ("Digite a segunda coordenada do 2 ponto: \n");
scanf ("%f", &y2);
Distancia = sqrt(pow(x2-x1,2)+ pow(y2-y1,2));
printf ("%.4f\n", Distancia);
return (0);
}
|
the_stack_data/220454776.c | /*
ID: freeord1
LANG: C
TASK: dualpal
*/
#include <stdio.h>
#include <assert.h>
#include <string.h>
int is_palidrome(int num, int base)
{
char li[1000];
int mod;
int i = 0;
while (num / base > 0) {
mod = num % base;
num /= base;
/* 2 <= base <= 10 */
li[i++] = '0' + mod;
}
li[i] = '0' + num;
li[i+1] = '\0';
i = 0;
int j = strlen(li) - 1;
while (i < j && li[i] == li[j]) {
++i;
--j;
}
if (i < j)
return 0;
else
return 1;
}
/* 1 --> positive
* 0 --> negative
*/
int is_dualpal(int num)
{
int count = 0;
int i;
for (i = 2; i <= 10; ++i) {
if (is_palidrome(num, i))
++count;
if (count == 2)
return 1;
}
return 0;
}
int main()
{
FILE *fin, *fout;
fin = fopen("dualpal.in", "r");
fout = fopen("dualpal.out", "w");
assert (fin && fout);
int num, start;
fscanf(fin, "%d %d", &num, &start);
fclose(fin);
int count = 0;
while (count < num) {
++start;
if (is_dualpal(start)) {
++count;
fprintf(fout, "%d\n", start);
}
}
fclose(fout);
return 0;
}
|
the_stack_data/161081515.c | //
// Created by zhang on 2017/1/6.
//
//C 库函数 double difftime(time_t time1, time_t time2) 返回 time1 和 time2 之间相差的秒数 (time1 - time2)。
// 这两个时间是在日历时间中指定的，表示了自纪元 Epoch（协调世界时 UTC：1970-01-01 00:00:00）起经过的时间。
//double difftime(time_t time1, time_t time2)
#include <stdio.h>
#include <time.h>
int difftime_main ()
{
time_t start_t, end_t;
double diff_t;
printf("start...\n");
time(&start_t);
printf("sleep...\n");
time(&end_t);
diff_t = difftime(end_t+1, start_t);
printf("execute time = %f\n", diff_t);
printf("exit...\n");
return(0);
} |
the_stack_data/75799.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
double evaluation(
FILE *file_simulation,
unsigned int nsimulation,
unsigned int xsimulation,
unsigned int ysimulation,
FILE *file_experiment,
unsigned int nexperiment,
unsigned int xexperiment,
unsigned int yexperiment,
double weight)
{
unsigned int i, end_simulation, ndata;
double e, ey, maxy, rs1[nsimulation], rs2[nsimulation], re[nexperiment];
e = 0.;
maxy = 0.;
end_simulation = ndata = 0;
for (i = 0; i < nsimulation; ++i)
if (fscanf(file_simulation, "%lf", rs2 + i) != 1) goto exit_evaluate;
do
{
for (i = 0; i < nexperiment; ++i)
if (fscanf(file_experiment, "%lf", re + i) != 1) goto exit_evaluate;
++ndata;
maxy = fmax(maxy, re[yexperiment]);
for (i = 0; i < nsimulation; ++i) rs1[i] = rs2[i];
if (rs1[xsimulation] > re[xexperiment])
ey = rs1[ysimulation] - re[yexperiment];
else if (!end_simulation)
{
do
{
for (i = 0; i < nsimulation; ++i) rs1[i] = rs2[i];
for (i = 0; i < nsimulation; ++i)
{
if (fscanf(file_simulation, "%lf", rs2 + i) != 1)
{
end_simulation = 1;
goto exit_simulation;
}
}
}
while (rs2[xsimulation] < re[xsimulation]);
ey = rs1[ysimulation] + (rs2[ysimulation] - rs1[ysimulation])
* (re[xexperiment] - rs1[xsimulation])
/ (rs2[xsimulation] - rs1[xsimulation])
- re[yexperiment];
}
exit_simulation:
if (end_simulation) ey = rs1[ysimulation] - re[yexperiment];
e += ey * ey;
}
while (1);
exit_evaluate:
if (weight != 0.) maxy = weight;
return e / (maxy * maxy * ndata);
}
int main(int argn, char **argc)
{
double e, ea, eh, es;
char buffer[512];
FILE *file_simulation, *file_experiment, *file_evaluation;
snprintf(buffer, 512, "mkdir %s", argc[9]);
system(buffer);
snprintf(buffer, 512, "cp mesh.in model.in probe.in times.in %s", argc[9]);
system(buffer);
snprintf(buffer, 512, "cp %s %s/field.in", argc[1], argc[9]);
system(buffer);
snprintf(buffer, 512, "cp %s %s/input.in", argc[2], argc[9]);
system(buffer);
snprintf(buffer, 512, "./surcos %s", argc[9]);
system(buffer);
e = 0.;
snprintf(buffer, 512, "%s/00b.out", argc[9]);
file_simulation = fopen(buffer, "r");
file_experiment = fopen(argc[3], "r");
ea = sqrt
(evaluation(file_simulation, 3, 0, 1, file_experiment, 2, 0, 1, 0.));
fclose(file_simulation);
fclose(file_experiment);
snprintf(buffer, 512, "%s/probes.out", argc[9]);
file_simulation = fopen(buffer, "r");
file_experiment = fopen(argc[4], "r");
eh = sqrt
(evaluation(file_simulation, 11, 0, 1, file_experiment, 2, 0, 1, 0.));
fclose(file_simulation);
fclose(file_experiment);
snprintf(buffer, 512, "%s/probes.out", argc[9]);
file_simulation = fopen(buffer, "r");
file_experiment = fopen(argc[5], "r");
es = evaluation(file_simulation, 11, 0, 4, file_experiment, 2, 0, 1, 10.6);
fclose(file_simulation);
fclose(file_experiment);
snprintf(buffer, 512, "%s/probes.out", argc[9]);
file_simulation = fopen(buffer, "r");
file_experiment = fopen(argc[6], "r");
es += evaluation(file_simulation, 11, 0, 6, file_experiment, 2, 0, 1, 10.6);
fclose(file_simulation);
fclose(file_experiment);
snprintf(buffer, 512, "%s/probes.out", argc[9]);
file_simulation = fopen(buffer, "r");
file_experiment = fopen(argc[7], "r");
es += evaluation(file_simulation, 11, 0, 8, file_experiment, 2, 0, 1, 10.6);
fclose(file_simulation);
fclose(file_experiment);
snprintf(buffer, 512, "%s/probes.out", argc[9]);
file_simulation = fopen(buffer, "r");
file_experiment = fopen(argc[8], "r");
es += evaluation(file_simulation, 10, 0, 8, file_experiment, 2, 0, 1, 10.6);
fclose(file_simulation);
fclose(file_experiment);
es = sqrt(es / 4);
printf("error in advance: %lg\n", ea);
printf("error in depth: %lg\n", eh);
printf("error in concentration: %lg\n", es);
e = ea + 0.5 * (eh + es);
printf("total error: %lg\n", e);
snprintf(buffer, 512, "rm -rf %s", argc[9]);
system(buffer);
file_evaluation = fopen(argc[9], "w");
fprintf(file_evaluation, "%.14le", e);
fclose(file_evaluation);
return 0;
}
|
the_stack_data/94157.c | void v(int i) {
int *j = &i;
}
|
the_stack_data/132951785.c | // ignore-license
// Pragma needed cause of gcc bug on windows: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
#include <assert.h>
#ifdef _MSC_VER
#pragma pack(push,1)
struct Foo {
char a;
short b;
char c;
};
#else
#pragma pack(1)
struct __attribute__((packed)) Foo {
char a;
short b;
char c;
};
#endif
struct Foo foo(struct Foo foo) {
assert(foo.a == 1);
assert(foo.b == 2);
assert(foo.c == 3);
return foo;
}
|
the_stack_data/1081118.c | #include<stdio.h>
int main(){
float sum = 0, a[64] = {0};
int count, i, c;
float n;
for(i = 0 ; scanf("%f", &n)!=EOF;){
a[i] = n;
int j = 1;
for(c = 0 ; c < i; c++){
if(a[c] == a[i])j = 0;
}
if(j)i++;
}
printf("%d\n", i);
for(count = 0; count < i; count++){
if (a[count] >= i){
while(a[count] >= i ){
a[count] -= i;
}
}
sum += a[count];
}
printf("%.3f\n", sum);
return 0;
}
|
the_stack_data/23575107.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_is_negative.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cado-car <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/06/14 23:09:26 by cado-car #+# #+# */
/* Updated: 2021/06/14 23:09:27 by cado-car ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar (char c);
void ft_is_negative(int n)
{
if (n >= 0)
ft_putchar('P');
else
ft_putchar('N');
}
void ft_putchar (char c)
{
write(1, &c, 1);
}
|
the_stack_data/150142027.c | #include <sys/types.h>
#include <stdint.h>
#include <stddef.h>
#undef KEY
#if defined(__i386)
# define KEY '_','_','i','3','8','6'
#elif defined(__x86_64)
# define KEY '_','_','x','8','6','_','6','4'
#elif defined(__ppc__)
# define KEY '_','_','p','p','c','_','_'
#elif defined(__ppc64__)
# define KEY '_','_','p','p','c','6','4','_','_'
#endif
#define SIZE (sizeof(unsigned long))
char info_size[] = {'I', 'N', 'F', 'O', ':', 's','i','z','e','[',
('0' + ((SIZE / 10000)%10)),
('0' + ((SIZE / 1000)%10)),
('0' + ((SIZE / 100)%10)),
('0' + ((SIZE / 10)%10)),
('0' + (SIZE % 10)),
']',
#ifdef KEY
' ','k','e','y','[', KEY, ']',
#endif
'\0'};
#ifdef __CLASSIC_C__
int main(argc, argv) int argc; char *argv[];
#else
int main(int argc, char *argv[])
#endif
{
int require = 0;
require += info_size[argc];
(void)argv;
return require;
}
|
the_stack_data/279113.c | #include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
for (int32_t i = 0; i <= 10; i++) {
switch (i) {
case 1:
case 2:
printf("1 or 2\n");
case 7:
printf("7\n");
default:
printf("default\n");
}
}
exit(EXIT_SUCCESS);
}
|
the_stack_data/212642020.c | /* Use numerical recipes in C styled memory management methods */
/*#include <malloc.h>*/
#include <stdlib.h>
#include <stdio.h>
int **imatrix(nrl,nrh,ncl,nch)
int nrl,nrh,ncl,nch;
{
int i;
int **m;
m=(int **) malloc((unsigned) (nrh-nrl+1)*sizeof(int*));
if (!m){
fprintf(stderr,"Unable to allocate %d int* s.\n",nrh-nrl+1);
return m;
}
m -= nrl;
for(i=nrl;i<=nrh;i++) {
m[i]=(int *) malloc((unsigned) (nch-ncl+1)*sizeof(int));
if (!m[i]) {
fprintf(stderr,"Unable to allocate %d'th row in an integer matrix.\n",
i-nrl+1);
return NULL;
}
m[i] -= ncl;
}
return m;
}
int *ivector(nl,nh)
int nl,nh;
{
int *v;
v=(int *)malloc((unsigned) (nh-nl+1)*sizeof(int) );
if (!v){
fprintf(stderr,"Unable to allocate %d int s.\n",nh-nl+1);
return v;
}
return(v-nl);
}
/* ARGSUSED */
void free_imatrix(m,nrl,nrh,ncl,nch)
int nrl,nrh,ncl,nch;
int **m;
{
int i;
for( i=nrh;i>=nrl;i-- )free( (char*) (m[i]+ncl) );
free((char*) (m+nrl));
}
/* ARGSUSED */
void free_ivector(v,nl,nh)
int *v;
int nl,nh;
{
free((char*) (v+nl));
}
double **dmatrix(nrl,nrh,ncl,nch)
int nrl,nrh,ncl,nch;
{
int i;
double **m;
m=(double **) malloc((unsigned) (nrh-nrl+1)*sizeof(double*));
if (!m){
fprintf(stderr,"Unable to allocate %d double* s.\n",nrh-nrl+1);
return m;
}
m -= nrl;
for(i=nrl;i<=nrh;i++) {
m[i]=(double *) malloc((unsigned) (nch-ncl+1)*sizeof(double));
if (!m[i]) {
fprintf(stderr,"Unable to allocate %d'th row in an double matrix.\n",
i-nrl+1);
return NULL;
}
m[i] -= ncl;
}
return m;
}
double *dvector(nl,nh)
int nl,nh;
{
double *v;
v=(double *)malloc((unsigned) (nh-nl+1)*sizeof(double) );
if (!v){
fprintf(stderr,"Unable to allocate %d double s.\n",nh-nl+1);
return v;
}
return(v-nl);
}
/* ARGSUSED */
void free_dmatrix(m,nrl,nrh,ncl,nch)
int nrl,nrh,ncl,nch;
double **m;
{
int i;
for( i=nrh;i>=nrl;i-- )free( (char*) (m[i]+ncl) );
free((char*) (m+nrl));
}
/* ARGSUSED */
void free_dvector(v,nl,nh)
double *v;
int nl,nh;
{
free((char*) (v+nl));
}
/* Add rows to a matrix:
imat pointer to that matrix
oldrowsize highest index+1 of old rows
newrowsize highest index+1 of new rows
colsize number of cols
*/
int grow_imatrix_byrows( imat, oldrowsize, newrowsize, colsize )
int ***imat, oldrowsize, newrowsize, colsize;
{
int i;
imat[0] = (int **) realloc(imat[0],
(unsigned) (newrowsize)*sizeof(int*));
if (!(imat[0])){
fprintf(stderr,"Unable to reallocate %d int* s.\n",newrowsize);
return 0;
}
for(i=oldrowsize; i<newrowsize; i++) {
imat[0][i] = (int *) malloc((unsigned) (colsize)*sizeof(int));
if (!imat[0][i]) {
fprintf(stderr,"Unable to reallocate %d'th row in an integer matrix.\n",
i);
return 0;
}
}
}
|
the_stack_data/76809.c | /* Simple S/MIME signing example */
#include <openssl/pem.h>
#include <openssl/pkcs7.h>
#include <openssl/err.h>
int main(int argc, char **argv)
{
BIO *in = NULL, *out = NULL, *tbio = NULL;
X509 *scert = NULL;
EVP_PKEY *skey = NULL;
PKCS7 *p7 = NULL;
int ret = 1;
/* For simple S/MIME signing use PKCS7_DETACHED.
* On OpenSSL 0.9.9 only:
* for streaming detached set PKCS7_DETACHED|PKCS7_STREAM
* for streaming non-detached set PKCS7_STREAM
*/
int flags = PKCS7_DETACHED|PKCS7_STREAM;
OpenSSL_add_all_algorithms();
ERR_load_crypto_strings();
/* Read in signer certificate and private key */
tbio = BIO_new_file("signer.pem", "r");
if (!tbio)
goto err;
scert = PEM_read_bio_X509(tbio, NULL, 0, NULL);
BIO_reset(tbio);
skey = PEM_read_bio_PrivateKey(tbio, NULL, 0, NULL);
if (!scert || !skey)
goto err;
/* Open content being signed */
in = BIO_new_file("sign.txt", "r");
if (!in)
goto err;
/* Sign content */
p7 = PKCS7_sign(scert, skey, NULL, in, flags);
if (!p7)
goto err;
out = BIO_new_file("smout.txt", "w");
if (!out)
goto err;
if (!(flags & PKCS7_STREAM))
BIO_reset(in);
/* Write out S/MIME message */
if (!SMIME_write_PKCS7(out, p7, in, flags))
goto err;
ret = 0;
err:
if (ret)
{
fprintf(stderr, "Error Signing Data\n");
ERR_print_errors_fp(stderr);
}
if (p7)
PKCS7_free(p7);
if (scert)
X509_free(scert);
if (skey)
EVP_PKEY_free(skey);
if (in)
BIO_free(in);
if (out)
BIO_free(out);
if (tbio)
BIO_free(tbio);
return ret;
}
|
the_stack_data/62636834.c | /*
C wrapper functions for in-line assembly.
In general, we must use in-line assembly when we wish to use a CPU
instruction explicitly. The most common reason to do this is to access some
CPU feature that is not available to us from the standard C programming
syntax.
Remarks:
[Documentation for in-line assembly in C](https://gcc.gnu.org/onlinedocs/gcc/Using-Assembly-Language-with-C.html#Using-Assembly-Language-with-C)
Use `gcc -masm` to set the in-line assembly syntax e.g. between GAS and NASM.
*/
unsigned char port_byte_in (unsigned short port) {
/*
Read a byte from the specified I/O port
"=a" (result) means: put AL register in value result when finished.
"d" (port) means: load EDX register with port.
*/
unsigned char result;
/*
Read from I/O port specified in DX into AL.
*/
__asm__("in al, dx" : "=a" (result) : "d" (port) );
/* __asm__("in %%dx, %%al" : "=a" (result) : "d" (port) ); */ // Author's given assembly, I change the assembly syntax to NASM to be consistent with our other assembly code like that in the boot sector.
return result;
}
void port_byte_out (unsigned short port, unsigned char data) {
/*
"a" (data) means: load EAX with data.
"d" (port) means: load EDX with port.
*/
/*
Write to I/O port DX the value specified in AL
*/
__asm__("out dx, al" : :"a" (data), "d" (port) );
/*__asm__("out %% al, %%dx" : :"a" (data), "d" (port) ); See note above. */
}
// TODO: port_WORD_in()
// TODO: port_WORD_out()
|
the_stack_data/7949278.c | /*Exercise 4 - Functions
Implement the three functions minimum(), maximum() and multiply() below the main() function.
Do not change the code given in the main() function when you are implementing your solution.*/
#include <stdio.h>
int minimum(int number1, int number2);
int maximum(int number1, int number2);
int multiply(int number1, int number2);
int main() {
int no1, no2;
printf("Enter a value for no 1 : ");
scanf("%d", &no1);
printf("Enter a value for no 2 : ");
scanf("%d", &no2);
printf("%d ", minimum(no1, no2));
printf("%d ", maximum(no1, no2));
printf("%d ", multiply(no1, no2));
return 0;
}
int minimum(int number1, int number2)
{
if(number1 > number2)
{
return number2;
}
else
{
return number1;
}
}
int maximum(int number1, int number2)
{
if(number1 > number2)
{
return number1;
}
else
{
return number2;
}
}
int multiply(int number1, int number2)
{
return number1 * number2;
}
|
the_stack_data/117472.c | //Palette created using Mollusk's PAGfxConverter
const unsigned short buttons_Pal[171] __attribute__ ((aligned (4))) = {
64543, 61109, 55888, 58001, 56910, 44195, 45252, 48421, 46309, 47365, 48455, 46341, 45285, 48390, 52520, 50439, 51495, 57871, 62232, 63354, 58962, 65535, 47366, 64445, 55658, 56748, 65502, 47334, 45253, 44228, 43204, 43172, 42148, 44227, 65326, 65328, 65091, 63008, 64032, 62976, 65088, 65120, 65124, 65056, 61954, 58789, 56679, 60867, 62977, 64033, 64064, 63040, 61985, 61984, 61952, 62080, 61172, 55854, 45251, 49479, 47333, 57966, 54601, 51496, 49511, 47397, 60084, 63322, 62199, 57839, 50567, 53705, 61142, 62265, 49415, 56781, 60019, 58961, 57904, 55692, 45284, 64379, 53544, 50471, 49414, 56911, 44229, 48358, 48454, 42147, 48422, 65358, 65090, 65092, 57735, 58790, 63009, 59844, 62978, 57734, 60900, 60868, 60899, 61922, 55624, 59845, 64001, 59812, 56711, 58820, 61953, 61921, 60898, 59843, 58788, 61920, 60928, 60896, 65123, 53545, 65089, 55625, 63010, 55656, 57766, 59875, 60866, 60930, 57765, 60115, 57937, 53707, 53740, 46308, 49447, 48423, 48391, 54569, 44196, 43171, 47367, 44226, 65325, 65296, 65059, 65060, 65057, 64000, 58821, 62049, 53706, 56876, 61955, 61923, 58757, 61924, 63011, 64034, 59813, 62979, 64065, 60929, 58819, 60897, 59873, 58787, 57764, 60865, 59842, 51463, 60931};
|
the_stack_data/38685.c |
/*+-------------------------------------------------------------------------
date2epsec.c - convert date to standard UNIX "seconds since epoch"
...!gatech!kd4nc!n4hgf!wht
Use -DUTC_CLK if date supplied is UTC, otherwise date supplied is
treated as expected to be local time
--------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:01-24-1997-02:38-wht@yuriatin-SOURCE RELEASE 4.00 */
/*:01-28-1990-04:55-wht-working on cmostime version 4 */
#include <sys/types.h>
#include <time.h>
/*+-------------------------------------------------------------------------
leap_year(yr) -- returns 1 if leap year, 0 otherwise
--------------------------------------------------------------------------*/
int
leap_year(yr)
int yr;
{
return((yr % 4 == 0) && (yr % 100 != 0) || (yr % 400 == 0));
} /* end of leap_year */
/*+-------------------------------------------------------------------------
days_since_epoch(year,month,day)
Return the number of days between Jan 1, 1970 and year,month,day
year is full year (e.g., 1988)
month is 0-11
day is 0-30 (must be legal day in month)
--------------------------------------------------------------------------*/
int
days_since_epoch(year,month,day)
int year;
int month;
register int day;
{
register int mm;
register int yy;
static char days_per_month[] = {31,28,31,30,31,30,31,31,30,31,30,31};
day++; /* adjust for day 0-n instead of 1-n */
for(yy = 1970; yy < year; ++yy)
{
day += 365;
if(leap_year(yy))
day++;
}
for(mm = 0; mm < month; ++mm)
day += days_per_month[mm] + (mm == 1 && leap_year(yy));
return(day);
} /* end of days_since_epoch */
/*+-------------------------------------------------------------------------
date_to_epochsecs(year,month,day,hour,min,sec)
Convert arguments into long seconds since 1/1/1970
year is full year (e.g., 1988)
month is 0-11
day is 0-30 (must be legal day in month)
hour is 0-23, min and sec 0-59
--------------------------------------------------------------------------*/
long
date_to_epochsecs(year,month,day,hour,min,sec)
int year;
int month;
int day;
int hour;
int min;
int sec;
{
register int m1;
register int m2;
long t;
struct tm *tp;
struct tm *localtime();
t = (days_since_epoch(year,month,day) - 1) * 86400L
+ (hour * 3600L) + (min * 60L) + sec;
#if !defined(UTC_CLK)
/* correct for the time zone */
tp = localtime(&t);
m1 = tp->tm_hour * 60 + tp->tm_min;
m2 = (hour * 60) + min;
t -= ((m1 - m2 + 720 + 1440) % 1440 - 720) * 60L;
#endif
return(t);
} /* end of date_to_epochsecs */
/* vi: set tabstop=4 shiftwidth=4: */
/* end of date2epsec.c */
|
the_stack_data/181389189.c | /*
ITS240-01
Lab 10
Ch11p572pe1
04/18/2017
Daniel Kuckuck
Write a C function that displays the day of the week cooresponding to a user-entered input number between 1 and 7. That is, in response to an input of 2, the program displays the name Monday. Use an array of pointers in the function. Part B: Include the function in a complete working program.
*/
#include <stdio.h>
#define LSIZE 81
/*struct Date
{
int day;
int month;
int year;
}; Wrong assaignment
*/
int main()
{
void weekDisplay(int);
int day = 0;
printf("\nPlease enter a number from 1 - 7 for the day you desire -->");
scanf("%d", &day);
weekDisplay(day);
//printf("\n");
return 0;
}
void weekDisplay(int day)
{
switch (day)
{
case 1:
printf("Sunday");
return;
case 2:
printf("Monday");
return;
case 3:
printf("Tuesday");
return;
case 4:
printf("Wednesday");
return;
case 5:
printf("Thursday");
return;
case 6:
printf("Friday");
return;
case 7:
printf("Saturday");
return;
default:;
}
return;
} |
the_stack_data/130334.c | /* The MIT License
Copyright (c) 2011 by Attractive Chaos <[email protected]>
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.
*/
// This file originally found here:
// https://raw.githubusercontent.com/attractivechaos/plb/master/sudoku/sudoku_v1.c
// This file implements an improved algorithm of Guenter Stertenbrink's suexco.c
// (http://magictour.free.fr/suexco.txt).
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
/* For Sudoku, there are 9x9x9=729 possible choices (9 numbers to choose for
each cell in a 9x9 grid), and 4x9x9=324 constraints with each constraint
representing a set of choices that are mutually conflictive with each other.
The 324 constraints are classified into 4 categories:
1. row-column where each cell contains only one number
2. box-number where each number appears only once in one 3x3 box
3. row-number where each number appears only once in one row
4. col-number where each number appears only once in one column
Each category consists of 81 constraints. We number these constraints from 0
to 323. In this program, for example, constraint 0 requires that the (0,0)
cell contains only one number; constraint 81 requires that number 1 appears
only once in the upper-left 3x3 box; constraint 162 requires that number 1
appears only once in row 1; constraint 243 requires that number 1 appears
only once in column 1.
Noting that a constraint is a subset of choices, we may represent a
constraint with a binary vector of 729 elements. Thus we have a 729x324
binary matrix M with M(r,c)=1 indicating the constraint c involves choice r.
Solving a Sudoku is reduced to finding a subset of choices such that no
choices are present in the same constraint. This is equivalent to finding the
minimal subset of choices intersecting all constraints, a minimum hitting
set problem or a equivalence of the exact cover problem.
The 729x324 binary matrix is a sparse matrix, with each row containing 4
non-zero elements and each column 9 non-zero elements. In practical
implementation, we store the coordinate of non-zero elements instead of
the binary matrix itself. We use a binary row vector to indicate the
constraints that have not been used and use a column vector to keep the
number of times a choice has been forbidden. When we set a choice, we will
use up 4 constraints and forbid other choices in the 4 constraints. When we
make wrong choices, we will find an unused constraint with all choices
forbidden, in which case, we have to backtrack to make new choices. Once we
understand what the 729x324 matrix represents, the backtracking algorithm
itself is easy.
A major difference between the algorithm implemented here and Guenter
Stertenbrink's suexco.c lies in how to count the number of the available
choices for each constraint. Suexco.c computes the count with a loop, while
the algorithm here keeps the count in an array. The latter is a little more
complex to implement as we have to keep the counts synchronized all the time,
but it is 50-100% faster, depending on the input.
*/
// the sparse representation of the binary matrix
typedef struct {
uint16_t r[324][9]; // M(r[c][i], c) is a non-zero element
uint16_t c[729][4]; // M(r, c[r][j]) is a non-zero element
} sdaux_t;
// generate the sparse representation of the binary matrix
sdaux_t *sd_genmat()
{
sdaux_t *a;
int i, j, k, r, c, c2, r2;
int8_t nr[324];
a = calloc(1, sizeof(sdaux_t));
for (i = r = 0; i < 9; ++i) // generate c[729][4]
for (j = 0; j < 9; ++j)
for (k = 0; k < 9; ++k) // this "9" means each cell has 9 possible numbers
a->c[r][0] = 9 * i + j, // row-column constraint
a->c[r][1] = (i/3*3 + j/3) * 9 + k + 81, // box-number constraint
a->c[r][2] = 9 * i + k + 162, // row-number constraint
a->c[r][3] = 9 * j + k + 243, // col-number constraint
++r;
for (c = 0; c < 324; ++c) nr[c] = 0;
for (r = 0; r < 729; ++r) // generate r[][] from c[][]
for (c2 = 0; c2 < 4; ++c2)
k = a->c[r][c2], a->r[k][nr[k]++] = r;
return a;
}
// update the state vectors when we pick up choice r; v=1 for setting choice; v=-1 for reverting
static inline int sd_update(const sdaux_t *aux, int8_t sr[729], uint8_t sc[324], int r, int v)
{
int c2, min = 10, min_c = 0;
for (c2 = 0; c2 < 4; ++c2) sc[aux->c[r][c2]] += v<<7;
for (c2 = 0; c2 < 4; ++c2) { // update # available choices
int r2, rr, cc2, c = aux->c[r][c2];
if (v > 0) { // move forward
for (r2 = 0; r2 < 9; ++r2) {
if (sr[rr = aux->r[c][r2]]++ != 0) continue; // update the row status
for (cc2 = 0; cc2 < 4; ++cc2) {
int cc = aux->c[rr][cc2];
if (--sc[cc] < min) // update # allowed choices
min = sc[cc], min_c = cc; // register the minimum number
}
}
} else { // revert
const uint16_t *p;
for (r2 = 0; r2 < 9; ++r2) {
if (--sr[rr = aux->r[c][r2]] != 0) continue; // update the row status
p = aux->c[rr]; ++sc[p[0]]; ++sc[p[1]]; ++sc[p[2]]; ++sc[p[3]]; // update the count array
}
}
}
return min<<16 | min_c; // return the col that has been modified and with the minimal available choices
}
// solve a Sudoku; _s is the standard dot/number representation
int sd_solve(const sdaux_t *aux, const char *_s, char *solution, size_t limit)
{
int i, j, r, c, r2, dir, cand, n = 0, min, hints = 0; // dir=1: forward; dir=-1: backtrack
int8_t sr[729], cr[81]; // sr[r]: # times the row is forbidden by others; cr[i]: row chosen at step i
uint8_t sc[324]; // bit 1-7: # allowed choices; bit 8: the constraint has been used or not
int16_t cc[81]; // cc[i]: col chosen at step i
for (r = 0; r < 729; ++r) sr[r] = 0; // no row is forbidden
for (c = 0; c < 324; ++c) sc[c] = 0<<7|9; // 9 allowed choices; no constraint has been used
for (i = 0; i < 81; ++i) {
int a = _s[i] >= '1' && _s[i] <= '9'? _s[i] - '1' : -1; // number from -1 to 8
if (a >= 0) sd_update(aux, sr, sc, i * 9 + a, 1); // set the choice
if (a >= 0) ++hints; // count the number of hints
cr[i] = cc[i] = -1, solution[i] = _s[i];
}
for (i = 0, dir = 1, cand = 10<<16|0;;) {
while (i >= 0 && i < 81 - hints) { // maximum 81-hints steps
if (dir == 1) {
min = cand>>16, cc[i] = cand&0xffff;
if (min > 1) {
for (c = 0; c < 324; ++c) {
if (sc[c] < min) {
min = sc[c], cc[i] = c; // choose the top constraint
if (min <= 1) break; // this is for acceleration; slower without this line
}
}
}
if (min == 0 || min == 10) cr[i--] = dir = -1; // backtrack
}
if (i < 0) {
return 0; // an inconsistency; no solution
}
c = cc[i];
if (dir == -1 && cr[i] >= 0) sd_update(aux, sr, sc, aux->r[c][cr[i]], -1); // revert the choice
for (r2 = cr[i] + 1; r2 < 9; ++r2) // search for the choice to make
if (sr[aux->r[c][r2]] == 0) break; // found if the state equals 0
if (r2 < 9) {
cand = sd_update(aux, sr, sc, aux->r[c][r2], 1); // set the choice
cr[i++] = r2; dir = 1; // moving forward
} else cr[i--] = dir = -1; // backtrack
}
if (i < 0) break;
for (j = 0; j < i; ++j) r = aux->r[cc[j]][cr[j]], solution[r/9] = r%9 + '1'; // print
++n; --i; dir = -1; // backtrack
if (n == limit) break;
}
return n; // return the number of solutions
}
sdaux_t *aux = NULL;
size_t OtherSolverKudoku(const char *input, size_t limit /* unused */,
uint32_t configuration /* unused */,
char *solution, size_t *num_guesses) {
if (aux == NULL) aux = sd_genmat();
*num_guesses = 0;
return sd_solve(aux, input, solution, limit);
}
|
the_stack_data/153268649.c | /* Origin: PR c/92 from Simon Marlow <[email protected]>, adapted
to a testcase by Joseph Myers <[email protected]>.
*/
typedef struct { } empty;
typedef struct {
int i;
empty e;
int i2;
} st;
st s = { .i = 0, .i2 = 1 };
extern void abort (void);
int
main (void)
{
if (s.i2 == 1)
exit (0);
else
abort ();
}
|
the_stack_data/480267.c | #include <stdio.h>
int partition(int arr[], int low, int high)
{
int pivot = arr[high]; // pivot the highest element
int i = low - 1; // Index of smaller element
for(int j = low; j <= high- 1; j++)
{
if(arr[j] < pivot)
{
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quick_sort(int arr[], int low, int high)
{
if(low < high)
{
int pi = partition(arr, low, high); // arr[pi] is sorted
quick_sort(arr, low, pi - 1);
quick_sort(arr, pi + 1, high);
}
} |
the_stack_data/26441.c | #include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
void error(char *msg)
{
perror(msg);
exit(0);
}
int main(int argc, char *argv[])
{
int sockfd, portno, n, i;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[256];
int length;
if (argc < 2) {
fprintf(stderr,"usage %s sourcename\n", argv[0]);
exit(0);
}
portno = 12345;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
server = gethostbyname("localhost");
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0)
error("ERROR connecting");
getcwd(buffer, 255);
strncat(buffer, "/\n", 2);
n = write(sockfd, buffer, strlen(buffer));
if (n < 0)
error("ERROR writing to socket");
for(i = 1; i < argc; i++) {
bzero(buffer,256);
strncat(buffer, argv[i], strlen(argv[i]));
strncat(buffer, "\n", 1);
n = write(sockfd, buffer, strlen(buffer));
if (n < 0)
error("ERROR writing to socket");
}
n = write(sockfd, "end\n", 4);
if (n < 0)
error("ERROR writing to socket");
bzero(buffer,256);
length = 0;
n = 1;
while(n > 0 && length < 255 && (length == 0 || buffer[length-1] != '\n')) {
n = read(sockfd,&buffer[length],255);
length += n;
}
if (n < 0)
error("ERROR reading from socket");
close(sockfd);
if(strncmp("ok\n", buffer, 3) == 0) {
printf("ok: %s",buffer);
return 0;
}
else if(strncmp("error", buffer, 5) == 0) {
fprintf(stderr, "error: %s", buffer);
return 1;
}
else {
printf("unknown return code: %s\n", buffer);
return 0;
}
}
|
the_stack_data/86075549.c | #include <stdio.h>
#include <stdlib.h>
#define MAX 5009
struct edge{
int to;
struct edge* next;
};
typedef struct edge edge;
edge graph[MAX];
int vis[MAX],out[MAX],N,M,top=1,topo[MAX],x;
edge* newedge(int to);
void addedge(int from,int to);
void read(void);
void dfs(int now);
int main(void)
{
int i;
read();
for(i=1;i<=N;++i) dfs(i);
for(i=N;i>=1;--i) printf("%d\n",topo[i]);
printf("%d\n",x);
return 0;
}
void dfs(int now)
{
if(vis[now]==1) return;
else{
edge* i;
int tot=0;
vis[now]=-1;
for(i=graph[now].next;i!=NULL;i=i->next){
if(!out[i->to]) ++tot;
dfs(i->to);
}
if(tot>1) x=1;
vis[now]=1;
topo[top++]=now;
}
}
void read(void)
{
int i;
scanf("%d%d",&N,&M);
for(i=0;i<M;++i){
int a,b;
scanf("%d%d",&a,&b);
addedge(a,b);
++out[a];
}
}
edge* newedge(int to)
{
edge* r=(edge*)malloc(sizeof(edge));
r->to=to;
r->next=NULL;
return r;
}
void addedge(int from,int to)
{
edge* n=newedge(to);
n->next=graph[from].next;
graph[from].next=n;
}
|
the_stack_data/25137753.c | /********************************************************
* gen -- Generate a bunch of random data *
* *
* Usage: *
* gen *
* *
* Outputs 500 lines of numbers from 1 to 40 *
********************************************************/
#include <stdlib.h>
#include <stdio.h>
const int MAX_LINES = 500; /* Number of lines to write */
const int MAX = 40; /* Maximum number */
int main()
{
int index; /* Loop index */
for (index = 0; index < MAX_LINES; ++index) {
int number; /* A random number */
number = rand();
printf("%d\n", (number % (MAX-1)) +1);
}
return (0);
}
|
the_stack_data/173577192.c | #define _GNU_SOURCE
// getAffinityReturnValue() et set_process_affinity()
// sont des extensions GNU.
#include <stdio.h>
#include <stdlib.h>
#include <sched.h>
cpu_set_t cpuSet; // stocker l'affinité du processus.
void get_process_affinity(){
int i = 0;
// Remise à zéro avant lecture de l'affinité.
CPU_ZERO(&cpuSet);
// sched_getaffinity retourne l'affinité d'un processus
// 0 : représente le processus en cours.
if(sched_getaffinity(0,
sizeof(cpu_set_t), &cpuSet) == -1){
perror("sched_getaffinity");
}
// Affichage de l'affinité.
for(i = 0; i < CPU_SETSIZE; i++) {
int isCPUSet = CPU_ISSET(i, &cpuSet);
if(isCPUSet){
printf("CPU[%d] is set for this process\n", i);
}
}
printf("-------------------------------------\n");
}
void set_process_affinity(){
/*
* Remise à zéro de l'affinité.
*/
CPU_ZERO(&cpuSet);
// Autoriser l'affinité sur les CPU1 et CPU2.
CPU_SET(0, &cpuSet);
CPU_SET(1, &cpuSet);
/* Interdire explicitement l'affinité sur les CPU3 et CPU4.
* (CPU_ZERO() interdit tout les CPU).
*/
CPU_CLR(2, &cpuSet);
// Appliquer les nouvelles régles d'affinité.
if( sched_setaffinity(0,
sizeof(cpu_set_t), &cpuSet) == -1 ){
perror("sched_setaffinity");
} else {
printf("-------------------------------------\n");
printf("--- CPU Affinity has been changed ---\n");
printf("-------------------------------------\n");
}
}
int main(int argc, char *argv[]){
get_process_affinity(); // Lecture de l'affinité initiale.
// Forcer l'affinité sur le CPU0 et CPU1.
set_process_affinity();
get_process_affinity(); // Relecture de l'affinité.
return EXIT_SUCCESS;
}
|
the_stack_data/69945.c | //Classification: #default/n/DAM/NP/gS/D(v)/lc/ln
//Written by: Sergey Pomelov
//Reviewed by: Igor Eremeev
//Comment:
#include <stdio.h>
int a;
int main(void)
{
int *p;
a = *p;
printf("%d",a);
return 0;
}
|
the_stack_data/31386533.c | #ifdef COMPILE_FOR_TEST
#include <assert.h>
#define assume(cond) assert(cond)
#endif
void main(int argc, char* argv[]) {
int x_0_0;//sh_buf.outcnt
int x_0_1;//sh_buf.outcnt
int x_0_2;//sh_buf.outcnt
int x_0_3;//sh_buf.outcnt
int x_0_4;//sh_buf.outcnt
int x_0_5;//sh_buf.outcnt
int x_0_6;//sh_buf.outcnt
int x_0_7;//sh_buf.outcnt
int x_1_0;//sh_buf.outbuf[0]
int x_1_1;//sh_buf.outbuf[0]
int x_2_0;//sh_buf.outbuf[1]
int x_2_1;//sh_buf.outbuf[1]
int x_3_0;//sh_buf.outbuf[2]
int x_3_1;//sh_buf.outbuf[2]
int x_4_0;//sh_buf.outbuf[3]
int x_4_1;//sh_buf.outbuf[3]
int x_5_0;//sh_buf.outbuf[4]
int x_5_1;//sh_buf.outbuf[4]
int x_6_0;//sh_buf.outbuf[5]
int x_7_0;//sh_buf.outbuf[6]
int x_8_0;//sh_buf.outbuf[7]
int x_9_0;//sh_buf.outbuf[8]
int x_10_0;//sh_buf.outbuf[9]
int x_11_0;//LOG_BUFSIZE
int x_11_1;//LOG_BUFSIZE
int x_12_0;//CREST_scheduler::lock_0
int x_13_0;//t3 T0
int x_14_0;//t2 T0
int x_15_0;//arg T0
int x_16_0;//functioncall::param T0
int x_16_1;//functioncall::param T0
int x_17_0;//buffered T0
int x_18_0;//functioncall::param T0
int x_18_1;//functioncall::param T0
int x_19_0;//functioncall::param T0
int x_19_1;//functioncall::param T0
int x_20_0;//functioncall::param T0
int x_20_1;//functioncall::param T0
int x_21_0;//functioncall::param T0
int x_21_1;//functioncall::param T0
int x_22_0;//direction T0
int x_23_0;//functioncall::param T0
int x_23_1;//functioncall::param T0
int x_24_0;//functioncall::param T0
int x_24_1;//functioncall::param T0
int x_25_0;//functioncall::param T0
int x_25_1;//functioncall::param T0
int x_26_0;//functioncall::param T0
int x_26_1;//functioncall::param T0
int x_27_0;//functioncall::param T0
int x_27_1;//functioncall::param T0
int x_28_0;//functioncall::param T0
int x_28_1;//functioncall::param T0
int x_29_0;//functioncall::param T0
int x_29_1;//functioncall::param T0
int x_30_0;//functioncall::param T0
int x_30_1;//functioncall::param T0
int x_31_0;//functioncall::param T0
int x_31_1;//functioncall::param T0
int x_32_0;//functioncall::param T0
int x_32_1;//functioncall::param T0
int x_33_0;//functioncall::param T0
int x_33_1;//functioncall::param T0
int x_34_0;//functioncall::param T0
int x_34_1;//functioncall::param T0
int x_35_0;//functioncall::param T1
int x_35_1;//functioncall::param T1
int x_36_0;//functioncall::param T1
int x_36_1;//functioncall::param T1
int x_37_0;//i T1
int x_37_1;//i T1
int x_37_2;//i T1
int x_38_0;//rv T1
int x_39_0;//rv T1
int x_39_1;//rv T1
int x_40_0;//functioncall::param T1
int x_40_1;//functioncall::param T1
int x_41_0;//functioncall::param T1
int x_41_1;//functioncall::param T1
int x_42_0;//functioncall::param T1
int x_42_1;//functioncall::param T1
int x_43_0;//functioncall::param T1
int x_43_1;//functioncall::param T1
int x_44_0;//functioncall::param T1
int x_44_1;//functioncall::param T1
int x_45_0;//functioncall::param T1
int x_45_1;//functioncall::param T1
int x_46_0;//functioncall::param T1
int x_46_1;//functioncall::param T1
int x_47_0;//functioncall::param T2
int x_47_1;//functioncall::param T2
int x_48_0;//functioncall::param T2
int x_48_1;//functioncall::param T2
int x_49_0;//i T2
int x_49_1;//i T2
int x_49_2;//i T2
int x_49_3;//i T2
int x_50_0;//rv T2
int x_51_0;//rv T2
int x_51_1;//rv T2
int x_52_0;//functioncall::param T2
int x_52_1;//functioncall::param T2
int x_53_0;//functioncall::param T2
int x_53_1;//functioncall::param T2
int x_54_0;//functioncall::param T2
int x_54_1;//functioncall::param T2
int x_55_0;//functioncall::param T2
int x_55_1;//functioncall::param T2
int x_56_0;//functioncall::param T2
int x_56_1;//functioncall::param T2
int x_57_0;//functioncall::param T2
int x_57_1;//functioncall::param T2
int x_57_2;//functioncall::param T2
int x_58_0;//functioncall::param T2
int x_58_1;//functioncall::param T2
int x_59_0;//functioncall::param T2
int x_59_1;//functioncall::param T2
int x_60_0;//functioncall::param T2
int x_60_1;//functioncall::param T2
T_0_0_0: x_0_0 = 0;
T_0_1_0: x_1_0 = 0;
T_0_2_0: x_2_0 = 0;
T_0_3_0: x_3_0 = 0;
T_0_4_0: x_4_0 = 0;
T_0_5_0: x_5_0 = 0;
T_0_6_0: x_6_0 = 0;
T_0_7_0: x_7_0 = 0;
T_0_8_0: x_8_0 = 0;
T_0_9_0: x_9_0 = 0;
T_0_10_0: x_10_0 = 0;
T_0_11_0: x_11_0 = 0;
T_0_12_0: x_13_0 = 2997821760;
T_0_13_0: x_14_0 = 1493758560;
T_0_14_0: x_15_0 = 0;
T_0_15_0: x_16_0 = 2132483778;
T_0_16_0: x_16_1 = -1;
T_0_17_0: x_17_0 = 0;
T_0_18_0: x_18_0 = 1064569456;
T_0_19_0: x_18_1 = x_17_0;
T_0_20_0: x_19_0 = 1537200729;
T_0_21_0: x_19_1 = 97;
T_0_22_0: x_20_0 = 1438610244;
T_0_23_0: x_20_1 = 0;
T_0_24_0: x_21_0 = 878273464;
T_0_25_0: x_21_1 = 0;
T_0_26_0: x_22_0 = 1493753920;
T_0_27_0: x_23_0 = 1905862023;
T_0_28_0: x_23_1 = x_22_0;
T_0_29_0: x_24_0 = 762325753;
T_0_30_0: x_24_1 = 0;
T_0_31_0: x_12_0 = -1;
T_0_32_0: x_0_1 = 5;
T_0_33_0: x_1_1 = 72;
T_0_34_0: x_2_1 = 69;
T_0_35_0: x_3_1 = 76;
T_0_36_0: x_4_1 = 76;
T_0_37_0: x_5_1 = 79;
T_0_38_0: x_25_0 = 1803214932;
T_0_39_0: x_25_1 = 83;
T_0_40_0: x_26_0 = 2116722633;
T_0_41_0: x_26_1 = 1;
T_0_42_0: x_27_0 = 1567000337;
T_0_43_0: x_27_1 = 1;
T_0_44_0: x_28_0 = 382749003;
T_0_45_0: x_28_1 = 1;
T_0_46_0: x_29_0 = 1524718875;
T_0_47_0: x_29_1 = 82;
T_0_48_0: x_30_0 = 777550362;
T_0_49_0: x_30_1 = 90;
T_0_50_0: x_31_0 = 2137140084;
T_0_51_0: x_31_1 = 1;
T_0_52_0: x_32_0 = 1369273595;
T_0_53_0: x_32_1 = 1;
T_0_54_0: x_33_0 = 679534030;
T_0_55_0: x_33_1 = 2;
T_0_56_0: x_34_0 = 1201595512;
T_0_57_0: x_34_1 = 2;
T_0_58_0: x_11_1 = 5;
T_1_59_1: x_35_0 = 1706430953;
T_1_60_1: x_35_1 = x_27_1;
T_1_61_1: x_36_0 = 8872198;
T_1_62_1: x_36_1 = x_28_1;
T_1_63_1: x_37_0 = 0;
T_1_64_1: x_38_0 = -1542315519;
T_2_65_2: x_47_0 = 169046236;
T_2_66_2: x_47_1 = x_33_1;
T_2_67_2: x_48_0 = 432543743;
T_2_68_2: x_48_1 = x_34_1;
T_2_69_2: x_49_0 = 0;
T_2_70_2: x_50_0 = -1612709375;
T_1_71_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_39_0 = 1500821424;
T_2_72_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0) x_51_0 = 1500821424;
T_2_73_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_52_0 = 885310905;
T_2_74_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_52_1 = -1;
T_2_75_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_51_1 = x_52_1;
T_2_76_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_51_1 + 1 == 0) x_0_2 = 0;
T_2_77_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0) x_53_0 = 590049964;
T_2_78_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0) x_53_1 = 9;
T_2_79_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0) x_54_0 = 1760444775;
T_2_80_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0) x_54_1 = x_53_1;
T_2_81_2: if (x_0_1 + x_48_1 > x_11_1 && x_0_1 != 0) x_0_3 = 0;
T_2_82_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_40_0 = 1163402560;
T_2_83_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_40_1 = -1;
T_2_84_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_18_1 == 0) x_39_1 = x_40_1;
T_1_85_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0 && x_18_1 == 0 && x_39_1 + 1 == 0) x_0_4 = 0;
T_1_86_1: if (x_48_1 < x_11_1) x_55_0 = 1999102831;
T_1_87_1: if (x_48_1 < x_11_1) x_55_1 = 47933447735040;
T_1_88_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_41_0 = 1322486314;
T_2_89_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_41_1 = 9;
T_2_90_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_42_0 = 569538920;
T_2_91_2: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_42_1 = x_41_1;
T_1_92_1: if (x_0_1 + x_36_1 > x_11_1 && x_0_1 != 0) x_0_5 = 0;
T_1_93_1: if (x_48_1 < x_11_1) x_56_0 = 1374121230;
T_1_94_1: if (x_48_1 < x_11_1) x_56_1 = x_0_4 + x_48_1;
T_1_95_1: if (x_48_1 < x_11_1) x_49_1 = 0;
T_2_96_2: if (x_48_1 < x_11_1 && x_49_1 < x_47_1) x_57_0 = 1302734403;
T_2_97_2: if (x_48_1 < x_11_1 && x_49_1 < x_47_1) x_57_1 = 47933447735040;
T_2_98_2: if (x_48_1 < x_11_1) x_49_2 = 1 + x_49_1;
T_2_99_2: if (x_48_1 < x_11_1 && x_49_2 < x_47_1) x_57_2 = 47933447735040;
T_2_100_2: if (x_48_1 < x_11_1) x_49_3 = 1 + x_49_2;
T_2_101_2: if (x_48_1 < x_11_1) x_58_0 = 1272620594;
T_2_102_2: if (x_48_1 < x_11_1) x_58_1 = 47933447735040;
T_2_103_2: if (x_48_1 < x_11_1) x_0_6 = x_0_5 + x_48_1;
T_2_104_2: if (x_36_1 < x_11_1) x_43_0 = 1359121360;
T_2_105_2: if (x_36_1 < x_11_1) x_43_1 = 47933377341184;
T_2_106_2: if (x_36_1 < x_11_1) x_44_0 = 219820211;
T_1_107_1: if (x_36_1 < x_11_1) x_44_1 = x_0_6 + x_36_1;
T_1_108_1: if (x_36_1 < x_11_1) x_37_1 = 0;
T_1_109_1: if (x_36_1 < x_11_1 && x_37_1 < x_35_1) x_45_0 = 662337675;
T_1_110_1: if (x_36_1 < x_11_1 && x_37_1 < x_35_1) x_45_1 = 47933377341184;
T_1_111_1: if (x_36_1 < x_11_1) x_37_2 = 1 + x_37_1;
T_1_112_1: if (x_36_1 < x_11_1) x_46_0 = 650247957;
T_1_113_1: if (x_36_1 < x_11_1) x_46_1 = 47933377341184;
T_1_114_1: if (x_36_1 < x_11_1) x_0_7 = x_0_6 + x_36_1;
T_1_115_1: if (x_48_1 < x_11_1) x_59_0 = 1098093675;
T_1_116_1: if (x_48_1 < x_11_1) x_59_1 = 47933447735040;
T_1_117_1: if (x_48_1 < x_11_1) x_60_0 = 420716050;
T_1_118_1: if (x_48_1 < x_11_1) x_60_1 = 47933447735040;
T_2_119_2: if (x_48_1 < x_11_1) assert(x_0_7 == x_56_1);
}
|
the_stack_data/145569.c | /* $NetBSD: err_syntax13.tab.c,v 1.1.1.1 2015/01/03 22:58:25 christos Exp $ */
/* original parser id follows */
/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYCHECK "yyyymmdd"
#define YYEMPTY (-1)
#define yyclearin (yychar = YYEMPTY)
#define yyerrok (yyerrflag = 0)
#define YYRECOVERING() (yyerrflag != 0)
#define YYENOMEM (-2)
#define YYEOF 0
|
the_stack_data/24912.c | #include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main() {
int t,i;
scanf("%d",&t);
long int arr[1000];
long int s=0;
for(i=0;i<t;i++)
{
scanf("%ld",&arr[i]);
}
for(i=0;i<t;i++)
{
s=s+arr[i];
}
printf("%ld",s);
return 0;
}
|
the_stack_data/61076116.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ultimate_div_mod.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tturna <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/12/05 06:14:50 by tturna #+# #+# */
/* Updated: 2021/12/05 06:15:20 by tturna ### ########.fr */
/* */
/* ************************************************************************** */
void ft_ultimate_div_mod(int *a, int *b)
{
int div;
int mod;
if (*b != 0)
{
div = (*a) / (*b);
mod = (*a) % (*b);
*a = div;
*b = mod;
}
}
|
the_stack_data/1033545.c | #include <stdio.h>
#define MAX 20
void brojiVelikaMala(char *niz, int *vel, int *mal) {
while (*niz != '\0') {
if (*niz >= 'A' && *niz <= 'Z') {
++*vel;
} else if (*niz >= 'a' && *niz <= 'z') {
++*mal;
}
niz++;
}
return;
}
int main(void) {
char niz[MAX + 1];
printf("Upisite niz > ");
fgets(niz, MAX + 1, stdin);
int vel = 0, mal = 0;
brojiVelikaMala(niz, &vel, &mal);
printf("Velikih: %d\nMalih: %d", vel, mal);
return 0;
} |
the_stack_data/117328384.c | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined HAVE_CONFIG_H
#include <config.h>
#endif
#if defined HADOOP_SNAPPY_LIBRARY
#if defined HAVE_STDIO_H
#include <stdio.h>
#else
#error 'stdio.h not found'
#endif
#if defined HAVE_STDLIB_H
#include <stdlib.h>
#else
#error 'stdlib.h not found'
#endif
#if defined HAVE_STRING_H
#include <string.h>
#else
#error 'string.h not found'
#endif
#if defined HAVE_DLFCN_H
#include <dlfcn.h>
#else
#error 'dlfcn.h not found'
#endif
#include "org_apache_hadoop_io_compress_snappy.h"
#include "org_apache_hadoop_io_compress_snappy_SnappyDecompressor.h"
static jfieldID SnappyDecompressor_clazz;
static jfieldID SnappyDecompressor_compressedDirectBuf;
static jfieldID SnappyDecompressor_compressedDirectBufLen;
static jfieldID SnappyDecompressor_uncompressedDirectBuf;
static jfieldID SnappyDecompressor_directBufferSize;
static snappy_status (*dlsym_snappy_uncompress)(const char*, size_t, char*, size_t*);
JNIEXPORT void JNICALL Java_org_apache_hadoop_io_compress_snappy_SnappyDecompressor_initIDs
(JNIEnv *env, jclass clazz){
// Load libsnappy.so
void *libsnappy = dlopen(HADOOP_SNAPPY_LIBRARY, RTLD_LAZY | RTLD_GLOBAL);
if (!libsnappy) {
char* msg = (char*)malloc(1000);
snprintf(msg, 1000, "%s (%s)!", "Cannot load " HADOOP_SNAPPY_LIBRARY, dlerror());
THROW(env, "java/lang/UnsatisfiedLinkError", msg);
return;
}
// Locate the requisite symbols from libsnappy.so
dlerror(); // Clear any existing error
LOAD_DYNAMIC_SYMBOL(dlsym_snappy_uncompress, env, libsnappy, "snappy_uncompress");
SnappyDecompressor_clazz = (*env)->GetStaticFieldID(env, clazz, "clazz",
"Ljava/lang/Class;");
SnappyDecompressor_compressedDirectBuf = (*env)->GetFieldID(env,clazz,
"compressedDirectBuf",
"Ljava/nio/Buffer;");
SnappyDecompressor_compressedDirectBufLen = (*env)->GetFieldID(env,clazz,
"compressedDirectBufLen", "I");
SnappyDecompressor_uncompressedDirectBuf = (*env)->GetFieldID(env,clazz,
"uncompressedDirectBuf",
"Ljava/nio/Buffer;");
SnappyDecompressor_directBufferSize = (*env)->GetFieldID(env, clazz,
"directBufferSize", "I");
}
JNIEXPORT jint JNICALL Java_org_apache_hadoop_io_compress_snappy_SnappyDecompressor_decompressBytesDirect
(JNIEnv *env, jobject thisj){
// Get members of SnappyDecompressor
jobject clazz = (*env)->GetStaticObjectField(env,thisj, SnappyDecompressor_clazz);
jobject compressed_direct_buf = (*env)->GetObjectField(env,thisj, SnappyDecompressor_compressedDirectBuf);
jint compressed_direct_buf_len = (*env)->GetIntField(env,thisj, SnappyDecompressor_compressedDirectBufLen);
jobject uncompressed_direct_buf = (*env)->GetObjectField(env,thisj, SnappyDecompressor_uncompressedDirectBuf);
size_t uncompressed_direct_buf_len = (*env)->GetIntField(env, thisj, SnappyDecompressor_directBufferSize);
// Get the input direct buffer
LOCK_CLASS(env, clazz, "SnappyDecompressor");
const char* compressed_bytes = (const char*)(*env)->GetDirectBufferAddress(env, compressed_direct_buf);
UNLOCK_CLASS(env, clazz, "SnappyDecompressor");
if (compressed_bytes == 0) {
return (jint)0;
}
// Get the output direct buffer
LOCK_CLASS(env, clazz, "SnappyDecompressor");
char* uncompressed_bytes = (char *)(*env)->GetDirectBufferAddress(env, uncompressed_direct_buf);
UNLOCK_CLASS(env, clazz, "SnappyDecompressor");
if (uncompressed_bytes == 0) {
return (jint)0;
}
snappy_status ret = dlsym_snappy_uncompress(compressed_bytes, compressed_direct_buf_len, uncompressed_bytes, &uncompressed_direct_buf_len);
if (ret == SNAPPY_BUFFER_TOO_SMALL){
THROW(env, "java/lang/InternalError", "Could not decompress data. Buffer length is too small.");
} else if (ret == SNAPPY_INVALID_INPUT){
THROW(env, "java/lang/InternalError", "Could not decompress data. Input is invalid.");
} else if (ret != SNAPPY_OK){
THROW(env, "java/lang/InternalError", "Could not decompress data.");
}
(*env)->SetIntField(env, thisj, SnappyDecompressor_compressedDirectBufLen, 0);
return (jint)uncompressed_direct_buf_len;
}
#endif //define HADOOP_SNAPPY_LIBRARY
|
the_stack_data/67324105.c |
#define EEDO 0x08 // EEPROM data out
#define EEDI 0x04 // EEPROM data in (set for writing data)
typedef unsigned short USHORT;
USHORT nondet();
int main(void)
{
USHORT data; // nondet
USHORT count; // nondet
USHORT x,mask; // nondet
mask = 0x01 << (count - 1);
x &= ~(EEDO | EEDI);
do
{
x &= ~EEDI;
if(data & mask)
x |= EEDI;
;
mask = mask >> 1;
} while(mask);
return 0;
}
|
the_stack_data/179831797.c | extern const unsigned char Pods_MXPagerView_SwiftVersionString[];
extern const double Pods_MXPagerView_SwiftVersionNumber;
const unsigned char Pods_MXPagerView_SwiftVersionString[] __attribute__ ((used)) = "@(#)PROGRAM:Pods_MXPagerView_Swift PROJECT:Pods-1" "\n";
const double Pods_MXPagerView_SwiftVersionNumber __attribute__ ((used)) = (double)1.;
|
the_stack_data/52194.c | /* Exercise 1 - Calculations
Write a C program to input marks of two subjects. Calculate and print the average of the two marks. */
#include <stdio.h>
int main() {
int sub1Mark, sub2Mark, sum;
float average;
printf("Input subject1 mark : ");
scanf("%d",&sub1Mark);
printf("Input subject2 mark : ");
scanf("%d",&sub2Mark);
sum = sub1Mark + sub2Mark;
average = sum/2.0;
printf("Average is %f",average);
return 0;
}
|
the_stack_data/392973.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2017 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 */
/*
* This test verifies that the application can block SEGV without interfering with Pin's
* ability to catch its own internally-generated SEGV's. This application causes Pin to
* speculatively fetch instructions from a page that is unreadable, which generates an
* internal SEGV in Pin. The test will only pass if Pin can handle that SEGV despite the
* fact that the application has blocked it.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/mman.h>
#include <unistd.h>
#ifndef MAP_ANONYMOUS
#ifdef MAP_ANON
#define MAP_ANONYMOUS MAP_ANON
#endif
#endif
/*
* We write this bit of machine code at the very end of a page, where the next page is unreadable.
* We then call to "Entry" and expect it to return back. This code snippet is constructed in
* such a way that Pin will speculatively fetch beyond the final JNE and attempt to fetch from
* the unreadable page.
*/
const unsigned char Code[] =
{
0xc3, /* L1: ret */
0x66, 0x83, 0xfc, 0x00, /* Entry: cmp $0x0,%sp */
0x75, 0xf9 /* jne L1 */
};
const size_t EntryOffset = 1; /* Offset of 'Entry' from start of 'Code' */
static void BlockSegv();
int main (int argc, char ** argv)
{
size_t pageSize;
char *twoPages;
/*
* Map a page of memory and ensure that the subsequent page is unreadable.
*/
pageSize = getpagesize();
twoPages = mmap(0, 2*pageSize, (PROT_READ|PROT_WRITE|PROT_EXEC), (MAP_PRIVATE|MAP_ANONYMOUS), -1, 0);
if (twoPages == MAP_FAILED)
{
printf("Unable to map pages\n");
return 1;
}
printf("Mapped two pages at %p\n", twoPages);
printf("Unprotecting page at %p\n", twoPages+pageSize);
if (mprotect(twoPages+pageSize, pageSize, PROT_NONE) != 0)
{
printf("Unable to unprotect second page\n");
return 1;
}
/*
* Copy the "Code" to the end of the page.
*/
memcpy(twoPages + pageSize - sizeof(Code), Code, sizeof(Code));
/*
* Block SEGV and then try to call the code snippet. Pin will try to
* fetch from the unreadable page, which raises SEGV. We want to make
* sure that the this doesn't cause a problem in Pin even though the
* application has SEGV blocked.
*/
BlockSegv();
((void (*)())(&twoPages[pageSize - sizeof(Code) + EntryOffset]))();
printf("Got back OK\n");
return 0;
}
static void BlockSegv()
{
sigset_t ss;
sigemptyset(&ss);
sigaddset(&ss, SIGSEGV);
if (sigprocmask(SIG_BLOCK, &ss, 0) != 0)
{
printf("Unable to block SEGV\n");
exit(1);
}
}
|
the_stack_data/234144.c | #include <stdio.h>
int markSource(int i) {
return i;
}
int sink(int i) {
return i;
}
int foo(int in) {
return in << 4;
}
int main(int argc, char const *argv[]) {
printf("Hello, world!\n");
int a = 23;
markSource(a);
int b = foo(a);
sink(b);
printf("%d\n", b);
return 0;
}
|
the_stack_data/40761896.c | /*
Дана очень длинная последовательность целых чисел длины N. Требуется вывести в отсортированном виде её наименьшие K элементов. Последовательность может не помещаться в память. Время работы O(N⋅logK), память O(K).
*/
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#define HEAP_TYPE long long
void swap(HEAP_TYPE *a, HEAP_TYPE *b) {
HEAP_TYPE tmp = *b;
*b = *a;
*a = tmp;
}
typedef struct Heap_t {
size_t size;
size_t capacity;
HEAP_TYPE *buffer;
int type;
} Heap;
void Heap_dump(Heap *cake) {
assert(cake);
printf("[DMP]<heap>\n");
printf("[ ]< >: [size](%zu)\n", cake->size);
printf("[ ]< >: [capacity](%zu)\n", cake->capacity);
printf("[ ]<.buf>: \n");
for (int i = 0; i < cake->capacity; ++i) {
printf("[ ]<%3d >: [](%lld) -> (%d) (%d)\n", i, cake->buffer[i], i * 2, i * 2 + 1);
}
}
void Heap_construct(Heap *cake, const size_t elem_cnt, int type) {
size_t cap = elem_cnt + 1;
cake->buffer = calloc(cap, sizeof(HEAP_TYPE));
assert(cake->buffer);
cake->size = 1;
cake->capacity = cap;
cake->type = type;
}
size_t Heap_size(Heap *cake) {
return cake->size - 1;
}
void Heap_destruct(Heap *cake) {
assert(cake);
free(cake->buffer);
}
void Heap_sift_up(Heap *cake, const size_t idx) {
assert(cake);
if (idx > cake->size || idx == 1) {
return;
}
const HEAP_TYPE val = cake->buffer[idx];
const HEAP_TYPE par = cake->buffer[idx / 2];
if (val > par) {
swap(&cake->buffer[idx], &cake->buffer[idx / 2]);
Heap_sift_up(cake, idx / 2);
}
}
void Heap_sift_down(Heap *cake, const size_t idx) {
assert(cake);
const size_t idx1 = idx * 2;
const size_t idx2 = idx * 2 + 1;
const HEAP_TYPE val = cake->buffer[idx];
if (idx1 < cake->size) {
const HEAP_TYPE val1 = cake->buffer[idx1];
if (idx2 < cake->size) {
const HEAP_TYPE val2 = cake->buffer[idx2];
if (val1 < val2) {
if (val < val2) {
swap(&cake->buffer[idx2], &cake->buffer[idx]);
Heap_sift_down(cake, idx2);
}
} else {
if (val < val1) {
swap(&cake->buffer[idx1], &cake->buffer[idx]);
Heap_sift_down(cake, idx1);
}
}
} else {
if (val < val1) {
swap(&cake->buffer[idx1], &cake->buffer[idx]);
Heap_sift_down(cake, idx1);
}
}
}
}
void Heap_push(Heap *cake, const HEAP_TYPE val) {
assert(cake);
cake->buffer[cake->size] = val * cake->type;
Heap_sift_up(cake, cake->size);
++cake->size;
}
void Heap_pop(Heap *cake) {
assert(cake);
--cake->size;
cake->buffer[1] = cake->buffer[cake->size];
Heap_sift_down(cake, 1);
}
HEAP_TYPE Heap_top(Heap *cake) {
assert(cake);
return cake->buffer[1] * cake->type;
}
// Будем хранить k наименьших элементов последовательности, ведь это как раз то, что нас просят делать
// Каждый раз пуша элементы и проверяя, не много ли их в куче, получим то, что и хотим
int main() {
int n = 0;
int k = 0;
scanf("%d %d", &n, &k);
Heap h = {};
Heap_construct(&h, k + 2, +1);
for (int i = 0; i < n; ++i) {
long long x = 0;
scanf("%lld", &x);
Heap_push(&h, x);
if (Heap_size(&h) > k) {
Heap_pop(&h);
}
}
long long *arr = calloc(k + 1, sizeof(long long));
while (Heap_size(&h)) {
//printf("%d) ", h.size - 1);
arr[h.size - 1] = Heap_top(&h);
//printf("%lld\n", arr[h.size]);
Heap_pop(&h);
}
for (int i = 1; i < k + 1; ++i) {
printf("%lld ", arr[i]);
}
printf("\n");
Heap_destruct(&h);
return 0;
}
//O(NlogK) - N запросов и работа с кучей не более чем на K элементов |
the_stack_data/156393216.c | #include<stdio.h>
int main()
{
int A[100],B[100],C[100],i,n,k,j;
printf("Enter the number of elements to be sorted: ");
scanf("%d",&n);
printf("Enter %d elements to be sorted: ",n);
for(i=1;i<=n;i++)
scanf("%d",&A[i]);
k=A[1];
for(i=1;i<=n;i++)
{
if(A[i]>k)
k=A[i];
}
for(i=0;i<=k;i++)
C[i]=0;
for(j=1;j<=n;j++)
C[A[j]]=C[A[j]]+1;
for(i=1;i<=k;i++)
C[i]=C[i]+C[i-1];
for(j=n;j>=1;j--)
{
B[C[A[j]]]=A[j];
C[A[j]]=C[A[j]]-1;
}
printf("The sorted elements are: ");
for(i=1;i<=n;i++)
printf("%d ",B[i]);
printf("\n");
return 0;
} |
the_stack_data/115921.c | /***************************************************************************
*
* Copyright (c) 2020 Baidu.com, Inc. All Rights Reserved
*
**************************************************************************/
/**
* @file pipe.c
* @author zhdaniel([email protected])
* @date 2020/01/17 02:52:45
* @brief
*
**/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char *argv[])
{
int fildes[2];
if (0 > pipe(fildes)) {
printf("failed to call pipe\n");
exit(1);
}
pid_t pid = fork();
switch (pid) {
case 0:
close(fildes[1]);
while (1) {
int i;
printf("blocking...\n");
int n = read(fildes[0], &i, sizeof(i));
printf("recv %d bytes: %02d\n", n, i);
if (n < 4) { printf("eof\n"); break; }
}
exit(0);
case -1:
exit(-1);
default:
close(fildes[0]);
for (int i = 2; i < 36; i++) {
int n = write(fildes[1], &i, sizeof(i));
printf("send %d bytes: %02d\n", n, i);
}
printf("close\n");
close(fildes[1]);
break;
}
printf("waiting\n");
int status;
wait(&status);
printf("done\n");
}
/* vim: set expandtab ts=4 sw=4 sts=4 tw=100: */
|
the_stack_data/95394.c | /*************************************************************************
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: myddas_postgres.c *
* Last rev: 22/03/05 *
* mods: *
* comments: Predicates for comunicating with a pq database system *
* *
*************************************************************************/
#if MYDDAS_POSTGRES
#include <libpq-fe.h>
#define BOOLOID 16
#define BYTEOID 17
#define CHAROID 18
#define NAMEOID 19
#define INT8OID 20
#define INT2OID 21
#define INT2VECTOROID 22
#define INT4OID 23
#define REGPROCOID 24
#define TEXTOID 25
#define OIDOID 26
#define TIDOID 27
#define XIDOID 28
#define CIDOID 29
#define OIDVECTOROID 30
#define JSONOID 114
#define XMLOID 142
#define PGNODETREEOID 194
#define POINTOID 600
#define LSEGOID 601
#define PATHOID 602
#define BOXOID 603
#define POLYGONOID 604
#define LINEOID 628
#define FLOAT4OID 700
#define FLOAT8OID 701
#define ABSTIMEOID 702
#define RELTIMEOID 703
#define TINTERVALOID 704
#define UNKNOWNOID 705
#define CIRCLEOID 718
#define CASHOID 790
#define MACADDROID 829
#define INETOID 869
#define CIDROID 650
#define INT2ARRAYOID 1005
#define INT4ARRAYOID 1007
#define TEXTARRAYOID 1009
#define OIDARRAYOID 1028
#define FLOAT4ARRAYOID 1021
#define ACLITEMOID 1033
#define CSTRINGARRAYOID 1263
#define BPCHAROID 1042
#define VARCHAROID 1043
#define DATEOID 1082
#define TIMEOID 1083
#define TIMESTAMPOID 1114
#define TIMESTAMPTZOID 1184
#define INTERVALOID 1186
#define TIMETZOID 1266
#define BITOID 1560
#define VARBITOID 1562
#define NUMERICOID 1700
#define REFCURSOROID 1790
#define REGPROCEDUREOID 2202
#define REGOPEROID 2203
#define REGOPERATOROID 2204
#define REGCLASSOID 2205
#define REGTYPEOID 2206
#define REGTYPEARRAYOID 2211
#define UUIDOID 2950
#define LSNOID 3220
#define TSVECTOROID 3614
#define GTSVECTOROID 3642
#define TSQUERYOID 3615
#define REGCONFIGOID 3734
#define REGDICTIONARYOID 3769
#define JSONBOID 3802
#define INT4RANGEOID 3904
#define RECORDOID 2249
#define RECORDARRAYOID 2287
#define CSTRINGOID 2275
#define ANYOID 2276
#define ANYARRAYOID 2277
#define VOIDOID 2278
#define TRIGGEROID 2279
#define EVTTRIGGEROID 3838
#define LANGUAGE_HANDLEROID 2280
#define INTERNALOID 2281
#define OPAQUEOID 2282
#define ANYELEMENTOID 2283
#define ANYNONARRAYOID 2776
#define ANYENUMOID 3500
#define FDW_HANDLEROID 3115
#define ANYRANGEOID 3831
#include "Yap.h"
#include "Yatom.h"
#include "YapText.h"
#include "cut_c.h"
#include "YapEval.h"
#include "myddas.h"
#ifdef MYDDAS_STATS
#include "myddas_structs.h"
#include "myddas_statistics.h"
#endif
#include "myddas_wkb2prolog.h"
#define CALL_POSTGRES(f) \
{ \
res = PQ ## f; \
if (PQstatus(db) != CONNECTION_OK) { \
fprintf(stderr, "Error %s when calling %s, line %d\n", \
PQerrorMessage(db), #f,__LINE__); \
exit (1); \
} \
PQclear(res); \
} \
#define GET_POSTGRES(f, res) \
{ \
res = PQ ## f; \
if (PQstatus(db) != CONNECTION_OK) { \
fprintf (stderr, "%s failed with status %s, line %d\n", \
#f, PQerrorMessage (db), __LINE__); \
exit (1); \
} \
} \
static Int NULL_id = 0;
typedef struct result_set {
PGconn *db;
PGresult *res;
const char *stmt;
int i ;
int nrows;
int ncols;
} resultSet;
void Yap_InitMYDDAS_PGPreds(void);
void Yap_InitBackMYDDAS_PGPreds(void);
static Int c_postgres_connect( USES_REGS1 );
static Int c_postgres_disconnect( USES_REGS1 );
static Int c_postgres_number_of_fields( USES_REGS1 );
static Int c_postgres_get_attributes_types( USES_REGS1 );
static Int c_postgres_query( USES_REGS1 );
static Int c_postgres_table_write( USES_REGS1 );
static Int c_postgres_row( USES_REGS1 );
static Int c_postgres_row_cut( USES_REGS1 );
static Int c_postgres_get_fields_properties( USES_REGS1 );
static Int c_postgres_get_next_result_set( USES_REGS1 );
static Int c_postgres_get_database( USES_REGS1 );
static Int c_postgres_change_database( USES_REGS1 );
void Yap_InitMYDDAS_PGPreds(void)
{
/* db_dbect: Host x User x Passwd x Database x dbection x ERROR_CODE */
Yap_InitCPred("c_postgres_connect", 7, c_postgres_connect, 0);
/* db_number_of_fields: Relation x connection x NumberOfFields */
Yap_InitCPred("c_postgres_number_of_fields",3, c_postgres_number_of_fields, 0);
/* db_get_attributes_types: Relation x TypesList */
Yap_InitCPred("c_postgres_get_attributes_types", 3, c_postgres_get_attributes_types, 0);
/* db_query: SQLQuery x ResultSet x conection */
Yap_InitCPred("c_postgres_query", 5, c_postgres_query, 0);
/* db_disconnect: connection */
Yap_InitCPred("c_postgres_disconnect", 1,c_postgres_disconnect, 0);
/* db_table_write: Result Set */
Yap_InitCPred("c_postgres_table_write", 1, c_postgres_table_write, 0);
/* db_get_fields_properties: PredName x connection x PropertiesList*/
Yap_InitCPred("c_postgres_get_fields_properties",3,c_postgres_get_fields_properties,0);
Yap_InitCPred("c_postgres_get_next_result_set",2,c_postgres_get_next_result_set,0);
/* c_postgres_get_database: connection x DataBaseName */
Yap_InitCPred("c_postgres_get_database",2,c_postgres_get_database,0);
/* c_postgres_change_database: connection x DataBaseName */
Yap_InitCPred("c_postgres_change_database",2,c_postgres_change_database,0);
}
void Yap_InitBackMYDDAS_PGPreds(void)
{
/* db_row: ResultSet x Arity x ListOfArgs */
Yap_InitCPredBackCut("c_postgres_row", 3, sizeof(Int),
c_postgres_row,
c_postgres_row,
c_postgres_row_cut, 0);
}
static Int
c_postgres_connect( USES_REGS1 ) {
int i=0;
Term arg_host = Deref(ARG1);
Term arg_user = Deref(ARG2);
Term arg_passwd = Deref(ARG3);
Term arg_database = Deref(ARG4);
Term arg_port = Deref(ARG5);
Term arg_socket = Deref(ARG6);
Term arg_conn = ARG7;
Term tempty = MkAtomTerm(Yap_LookupAtom(""));
Term tzero = MkIntTerm(0);
const char *keywords[8], *values[8];
char ports[16];
if (IsApplTerm(arg_host)) {
keywords[i] = "hostaddr";
values[i++] = RepAtom(AtomOfTerm(ArgOfTerm(1, arg_host)))->StrOfAE;
} else {
keywords[i] = "host";
values[i++] = RepAtom(AtomOfTerm(arg_host))->StrOfAE;
}
if (IsNonVarTerm(arg_user) && arg_user != tempty && IsAtomTerm(arg_user)) {
keywords[i] = "user";
values[i++] = RepAtom(AtomOfTerm(arg_user))->StrOfAE;
}
if (IsNonVarTerm(arg_user) && arg_passwd != tempty && IsAtomTerm(arg_passwd)) {
keywords[i] = "password";
values[i++] = RepAtom(AtomOfTerm(arg_passwd))->StrOfAE;
}
if (IsNonVarTerm(arg_user) && arg_database != tempty && IsAtomTerm(arg_database)) {
keywords[i] = "dbase";
values[i++] = RepAtom(AtomOfTerm(arg_database))->StrOfAE;
}
if (IsNonVarTerm(arg_user) && arg_port != tzero && IsIntTerm(arg_port)) {
keywords[i] = "port";
snprintf(ports, sizeof(ports)-1, "%d", (int)IntOfTerm(arg_port));
values[i++] = ports;
} else if (IsNonVarTerm(arg_socket) && arg_socket != tempty && IsIntTerm(arg_socket)) {
keywords[i] = "port";
values[i++] = RepAtom(AtomOfTerm(arg_database))->StrOfAE;
}
keywords[i] = NULL;
values[i++] = NULL;
/* Make a connection to the database */
PGconn *db = PQconnectdbParams(keywords, values, 0);
/* Check to see that the backend c onnection was successfully made */
if (PQstatus(db) != CONNECTION_OK)
{
fprintf(stderr, "Connection to database failed: %s",
PQerrorMessage(db));
return FALSE;
}
if (!Yap_unify(arg_conn, MkAddressTerm(db)))
return FALSE;
else
{
/* Criar um novo no na lista de ligacoes*/
MYDDAS_UTIL_CONNECTION cnew = myddas_util_add_connection(db,NULL,MYDDAS_POSTGRES);
if (cnew == NULL){
#ifdef DEBUG
printf("ERROR: ** c_db_my_connect ** Error allocating memory\n");
#endif
return FALSE;
}
return TRUE;
}
}
static MYDDAS_STATS_TIME
myddas_stat_init_query( PGconn *db )
{
#ifdef MYDDAS_STATS
MYDDAS_UTIL_connecTION node = myddas_util_search_connection(db);
MyddasULInt count = 0;
/* Count the number of querys made to the server */
MyddasULInt number_querys;
MYDDAS_STATS_CON_GET_NUMBER_QUERIES_MADE(node,number_querys);
MYDDAS_STATS_CON_SET_NUMBER_QUERIES_MADE(node,++number_querys);
MYDDAS_STATS_CON_GET_NUMBER_QUERIES_MADE_COUNT(node,count);
MYDDAS_STATS_CON_SET_NUMBER_QUERIES_MADE_COUNT(node,++count);
/* Measure time spent by the PG Server
processing the SQL Query */
return myddas_stats_walltime();
#else
return NULL;
#endif
}
static MYDDAS_STATS_TIME
myddas_stat_end_query( MYDDAS_STATS_TIME start )
{
MYDDAS_STATS_TIME diff = NULL;
#ifdef MYDDAS_STATS
/* Measure time spent by the PG Server
processing the SQL Query */
MYDDAS_STATS_TIME end = myddas_stats_walltime();
MYDDAS_STATS_INITIALIZE_TIME_STRUCT(diff,time_copy);
myddas_stats_subtract_time(diff,end,start);
diff = myddas_stats_time_copy_to_final(diff);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_CON_GET_TOTAL_TIME_DBSERVER(node,total_time);
/* Automacally updates the MYDDAS_STRUCTURE */
myddas_stats_add_time(total_time,diff,total_time);
MYDDAS_STATS_CON_GET_TOTAL_TIME_DBSERVER_COUNT(node,count);
MYDDAS_STATS_CON_SET_TOTAL_TIME_DBSERVER_COUNT(node,++count);
MYDDAS_STATS_TIME time = NULL;
MYDDAS_STATS_CON_GET_LAST_TIME_DBSERVER(node,time);
myddas_stats_move_time(diff,time);
MYDDAS_STATS_CON_GET_LAST_TIME_DBSERVER_COUNT(node,count);
MYDDAS_STATS_CON_SET_LAST_TIME_DBSERVER_COUNT(node,++count);
#endif
return diff;
}
#ifdef MYDDAS_STATS
/* measure transfer time */
static void
myddas_stat_transfer_query( MYDDAS_STATS_TIME diff )
{
/* Measure time spent by the PG Server
transferring the result of the last query
back to the client */
start = myddas_stats_walltime();
/* Measure time spent by the PG Server
transferring the result of the last query
back to the client */
end = myddas_stats_walltime();
MYDDAS_STATS_INITIALIZE_TIME_STRUCT(diff,time_copy);
myddas_stats_subtract_time(diff,end,start);
diff = MYDDAS_STATS_TIME_copy_to_final(diff);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_CON_GET_TOTAL_TIME_TRANSFERING(node,total_time);
/* Automacally updates the MYDDAS_STRUCTURE */
myddas_stats_add_time(total_time,diff,total_time);
MYDDAS_STATS_CON_GET_TOTAL_TIME_TRANSFERING_COUNT(node,count);
MYDDAS_STATS_CON_SET_TOTAL_TIME_TRANSFERING_COUNT(node,++count);
time = NULL;
MYDDAS_STATS_CON_GET_LAST_TIME_TRANSFERING(node,time);
MYDDAS_STATS_CON_GET_LAST_TIME_TRANSFERING_COUNT(node,count);
MYDDAS_STATS_CON_SET_LAST_TIME_TRANSFERING_COUNT(node,++count);
myddas_stats_move_time(diff,time);
/* Measure the number of Rows returned from the server */
if (res_set != NULL)
{
/* With an INSERT statement, PG_(use or store)_result()
returns a NULL pointer*/
/* This is only works if we use PG_store_result */
MyddasUInt numberRows = PG_num_rows(res_set);
MyddasUInt rows;
myddas_stat_transfer_query( diff );
MYDDAS_STATS_CON_GET_TOTAL_ROWS(node,rows);
numberRows = numberRows + rows;
MYDDAS_STATS_CON_SET_TOTAL_ROWS(node,numberRows);
MYDDAS_STATS_CON_GET_TOTAL_ROWS_COUNT(node,count);
MYDDAS_STATS_CON_SET_TOTAL_ROWS_COUNT(node,++count);
/* Calculate the ammount of data sent by the server */
MyddasUInt total,number_fields = PG_num_fields(res_set);
PG_ROW row;
MyddasULInt i;
total=0;
while ((row = PG_fetch_row(res_set)) != NULL){
PG_field_seek(res_set,0);
for(i=0;i<number_fields;i++){
if (row[i] != NULL)
total = total + strlen(row[i]);
}
}
MYDDAS_STATS_CON_SET_LAST_BYTES_TRANSFERING_FROM_DBSERVER(node,total);
MYDDAS_STATS_CON_GET_LAST_BYTES_TRANSFERING_FROM_DBSERVER_COUNT(node,count);
MYDDAS_STATS_CON_SET_LAST_BYTES_TRANSFERING_FROM_DBSERVER_COUNT(node,++count);
MyddasUInt bytes = 0;
MYDDAS_STATS_CON_GET_TOTAL_BYTES_TRANSFERING_FROM_DBSERVER(node,bytes);
total = total + bytes;
MYDDAS_STATS_CON_SET_TOTAL_BYTES_TRANSFERING_FROM_DBSERVER(node,total);
MYDDAS_STATS_CON_GET_TOTAL_BYTES_TRANSFERING_FROM_DBSERVER_COUNT(node,count);
MYDDAS_STATS_CON_SET_TOTAL_BYTES_TRANSFERING_FROM_DBSERVER_COUNT(node,++count);
}
}
#endif
/* db_query: SQLQuery x ResultSet x connection */
static Int
c_postgres_query( USES_REGS1 ) {
Term arg_sql_query = Deref(ARG1);
Term arg_result_set = Deref(ARG2);
Term arg_db = Deref(ARG3);
Term arg_mode = Deref(ARG4);
Term arg_arity = ARG5;
const char *sql = AtomName(AtomOfTerm(arg_sql_query));
const char *mode = AtomName(AtomOfTerm(arg_mode));
PGresult *res;
PGconn *db = AddressOfTerm(arg_db);
struct result_set *rs = malloc(sizeof( struct result_set));
if (!rs)
return FALSE;
rs->db = db;
rs->i = 0;
MYDDAS_STATS_TIME start, end;
start = myddas_stat_init_query( db );
const char *stmt = AtomName(Yap_LookupAtom(sql));
/* Send query to server and process it */
if (strcmp(mode,"store_result")!=0) {
// Leave data for extraction
CALL_POSTGRES (prepare(db, stmt, sql, 0, NULL) );
GET_POSTGRES (describePrepared(db, stmt) , res );
rs->stmt = stmt;
rs->res = NULL;
rs->nrows = -1;
rs->ncols = PQnfields(res);
if (!Yap_unify(arg_arity, MkIntegerTerm(rs->ncols)))
{
free(rs);
return FALSE;
}
if (!Yap_unify(arg_result_set, MkAddressTerm( rs)))
{
free(rs);
return FALSE;
}
return TRUE;
} else {
// construct an intermediate table, res_set
int nrows, ncols;
GET_POSTGRES (exec(db, sql), res );
end = myddas_stat_end_query( start );
ncols = PQnfields(res);
nrows = PQntuples(res);
//INSERT statements don't return any res_set
if (nrows == 0) {
return TRUE;
}
if (!Yap_unify(arg_arity, MkIntegerTerm(nrows))){
/*
* Should PGclear PGresult whenever it is no longer needed to avoid memory
* leaks
*/
free(rs);
PQclear(res);
return FALSE;
}
rs->stmt = NULL;
rs->res = res;
rs->nrows = nrows;
rs->ncols = ncols;
if (!Yap_unify(arg_result_set, MkAddressTerm( rs)))
{
free(rs);
PQclear(res);
return FALSE;
}
}
return TRUE;
}
static Int
c_postgres_number_of_fields( USES_REGS1 ) {
Term arg_relation = Deref(ARG1);
Term arg_db = Deref(ARG2);
Term arg_fields = ARG3;
const char *relation = AtomName(AtomOfTerm(arg_relation));
PGconn *db = AddressOfTerm(arg_db);
const char *stmt;
PGresult *res;
char sql[256];
snprintf(sql, 255, "SELECT * FROM TABLE `%s`",relation);
// Leave data for extraction
stmt = AtomName(Yap_LookupAtom(sql));
CALL_POSTGRES (prepare(db, stmt, sql, 0, NULL) );
/* executar a query SQL */
int nrows = PQntuples(res);
PQclear( res );
return Yap_unify(arg_fields, MkIntegerTerm( nrows ));
}
/* db_get_attributes_types: RelName x connection -> TypesList */
static Int
c_postgres_get_attributes_types( USES_REGS1 ) {
Term arg_relation = Deref(ARG1);
Term arg_db = Deref(ARG2);
Term arg_types_list = Deref(ARG3);
Term list, head;
const char *relation = AtomName(AtomOfTerm(arg_relation));
PGconn *db = AddressOfTerm(arg_db);
char sql[256];
//int row;
PGresult *res;
const char *stmt;
Int rc = TRUE;
sprintf(sql,"SELECT * FROM TABLE `%s`",relation);
// Leave data for extraction
stmt = AtomName(Yap_LookupAtom(sql));
// Leave data for extraction
GET_POSTGRES (prepare(db, stmt, sql, 0, NULL), res );
/* executar a query SQL */
int cols = PQnfields( res ), col;
list = arg_types_list;
for (col = 0; col < cols; col++)
{
const char *tm;
head = HeadOfTerm(list);
rc = (
rc && Yap_unify(head, MkAtomTerm(Yap_LookupAtom(PQfname(res, col))) ) );
list = TailOfTerm(list);
head = HeadOfTerm(list);
list = TailOfTerm(list);
Oid type = PQftype(res, col);
switch(type) {
case BYTEOID:
case CHAROID:
case INT2OID:
case INT4OID:
case INT8OID:
tm = "integer";
break;
case FLOAT4OID:
case FLOAT8OID:
tm = "real";
break;
case NAMEOID:
tm = "atom";
break;
case TEXTOID:
tm = "string";
break;
default:
tm = "unknown type";
break;
}
if (!Yap_unify(head, MkAtomTerm(Yap_LookupAtom(tm))) )
rc = FALSE;
}
PQclear( res );
return rc;
}
/* db_disconnect */
static Int
c_postgres_disconnect( USES_REGS1 ) {
Term arg_db = Deref(ARG1);
PGconn *db = AddressOfTerm(arg_db);
if ((myddas_util_search_connection(db)) != NULL)
{
myddas_util_delete_connection(db);
PQfinish(db);
return TRUE;
}
else
{
return FALSE;
}
}
/* db_table_write: Result Set */
static Int
c_postgres_table_write( USES_REGS1 ) {
/*
Term arg_res_set = Deref(ARG1);
PG_RES *res_set = (PG_RES *) IntegerOfTerm(arg_res_set);
mydas_util_table_write(res_set);
PG_free_result(res_set);
*/
return TRUE;
}
static Int
c_postgres_get_fields_properties( USES_REGS1 ) {
Term nome_relacao = Deref(ARG1);
Term arg_db = Deref(ARG2);
Term fields_properties_list = Deref(ARG3);
Term head, list;
PGresult *res;
const char *relation = AtomName(AtomOfTerm(nome_relacao));
char sql[256];
Int num_fields,i;
PGconn *db = AddressOfTerm(arg_db);
sprintf(sql,"\\d+ `%s`",relation);
GET_POSTGRES (exec(db, sql), res );
#if MYDDAS_STATS
end = myddas_stat_end_query( start );
#endif
Functor functor = Yap_MkFunctor(Yap_LookupAtom("property"),4);
list = fields_properties_list;
num_fields = PQntuples(res);
int coln;
const char *propname;
if (( coln = PQfnumber(res,"Column")) < 0)
return FALSE;
if (( propname = PQfname(res,2)) == NULL)
return FALSE;
if (!strstr(propname, "Table") || !strstr(propname, "Modifiers") )
return FALSE;
for (i=0;i<num_fields;i++)
{
Term properties[4];
head = HeadOfTerm(list);
if (!PQgetisnull(res, i, coln)) {
const char *col = PQgetvalue(res, i, coln);
properties[0] = MkAtomTerm(Yap_LookupAtom(col));
}
if (!PQgetisnull(res, i, 2)) {
const char *props = PQgetvalue(res, i, 2);
properties[1] = MkIntegerTerm(strstr(props, "not null") != NULL); //Can't be NULL
properties[2] = MkIntegerTerm(strstr(props, "prim") != NULL); //Can't be NULL
properties[3] = MkIntegerTerm(strstr(props, "nextval") != NULL); //Can't be NULL
}
list = TailOfTerm(list);
if (!Yap_unify(head, Yap_MkApplTerm(functor,4,properties))){
return FALSE;
}
}
PQclear(res);
return TRUE;
}
/* c_postgres_get_next_result_set: connection * NextResSet */
static Int
c_postgres_get_next_result_set( USES_REGS1 ) {
//Term arg_db = Deref(ARG1);
//Term arg_next_res_set = Deref(ARG2);
//PGconn *db = AddressOfTerm(arg_db);
return FALSE;
}
static Int
c_postgres_get_database( USES_REGS1 ) {
Term arg_con = Deref(ARG1);
Term arg_database = Deref(ARG2);
if (!Yap_unify(arg_database,arg_con))
return FALSE;
return TRUE;
}
static Int
c_postgres_change_database( USES_REGS1 ) {
/* no-op for now */
return TRUE;
}
static Int
c_postgres_row_cut( USES_REGS1 ) {
struct result_set *res_set=NULL;
PGconn *db = res_set->db;
res_set = AddressOfTerm(EXTRA_CBACK_CUT_ARG(Term,1));
PQclear( res_set->res );
PQfinish( db );
free(res_set);
return TRUE;
}
#define cvt( s ) cvt__( s PASS_REGS )
static Term
cvt__(const char *s USES_REGS) {
return Yap_CharsToTDQ( s, CurrentModule, ENC_ISO_LATIN1 PASS_REGS);
}
/* db_row: ResultSet x Arity_ListOfArgs x ListOfArgs -> */
static Int
c_postgres_row( USES_REGS1 ) {
#ifdef MYDDAS_STATS
/* Measure time used by the */
/* c_postgres_row function */
//MYDDAS_STATS_TIME start,end,total_time,diff;
MyddasULInt count = 0;
MYDDAS_STATS_TIME start, end;
start = myddas_stats_walltime();
#endif
Term arg_result_set = Deref(ARG1);
Term arg_arity = Deref(ARG2);
Term arg_list_args = Deref(ARG3);
Int rc = TRUE;
if (IsVarTerm( arg_result_set ) ) {
if (!c_postgres_query( PASS_REGS1 ) ) {
cut_fail();
}
arg_result_set = Deref(ARG1);
EXTRA_CBACK_ARG(3,1)= arg_result_set ;
EXTRA_CBACK_ARG(3,2)= MkIntegerTerm(0) ;
}
struct result_set *res_set = AddressOfTerm(arg_result_set);
Term head, list, NULL_atom[1];
Int arity;
list = arg_list_args;
arity = IntegerOfTerm(arg_arity);
PGconn *db = res_set->db;
if (res_set->stmt == NULL ) {
CACHE_REGS
Int i= IntegerOfTerm(EXTRA_CBACK_CUT_ARG(Term,2)), j;
Int rc = true;
// data needs to be copied to Prolog
// row by row
#ifdef MYDDAS_STATS
MYDDAS_STATS_TIME diff;
MYDDAS_STATS_INITIALIZE_TIME_STRUCT(diff,time_copy);
#endif
for (j = 0; j < arity; j++)
{
/* Ts -> List */
const char *field = PQgetvalue(res_set->res, i, j);
head = HeadOfTerm(list);
list = TailOfTerm(list);
rc = (rc && Yap_unify(head, cvt( field )) );
}
if (rc) {
EXTRA_CBACK_ARG(3,2)= MkIntegerTerm(i+1);
return rc;
}
#ifdef MYDDAS_STATS
myddas_stat_transfer_query( diff );
#endif
cut_fail();
}
// busy-waiting
if (!PQsetnonblocking(res_set->db, 1)) {
fprintf(stderr, "Connection to database failed: %s",
PQerrorMessage(db));
return FALSE;
}
if (!PQsendQueryPrepared(res_set->db, res_set->stmt, 0, NULL, NULL, NULL, 0)) {
fprintf(stderr, "Connection to database failed: %s",
PQerrorMessage(db));
return FALSE;
}
PGresult *res;
while((res = PQgetResult(res_set->db)) != NULL);
int i;
if ((i = res_set->nrows) == 0) {
// no more data
PQfinish( res_set->db );
free(res_set);
#ifdef MYDDAS_STATS
end = myddas_stats_walltime();
MYDDAS_STATS_INITIALIZE_TIME_STRUCT(diff,time_copy);
myddas_stats_subtract_time(diff,end,start);
diff = myddas_stats_time_copy_to_final(diff);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_GET_DB_ROW_FUNCTION(total_time);
myddas_stats_add_time(total_time,diff,total_time);
MYDDAS_STATS_GET_DB_ROW_FUNCTION_COUNT(count);
MYDDAS_STATS_SET_DB_ROW_FUNCTION_COUNT(++count);
MYDDAS_FREE(diff,struct myddas_stats_time_struct);
#endif /* MYDDAS_STATS */
cut_fail(); /* This macro already does a return FALSE */
} else if (i < res_set->nrows) {
list = arg_list_args;
Term tf;
int j;
for (j = 0; j < arity; j++)
{
/* convert data types here */
head = HeadOfTerm(list);
list = TailOfTerm(list);
if (!PQgetisnull(res, i, j)) {
const char *col = PQgetvalue(res, i, j);
tf = MkAtomTerm(Yap_LookupAtom(col));
} else {
NULL_atom[0] = MkIntegerTerm(NULL_id++);
tf = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("NULL"),1),1,NULL_atom);
}
}
if (!Yap_unify(head, tf))
rc = FALSE;
#ifdef MYDDAS_STATS
end = myddas_stats_walltime();
myddas_stats_subtract_time(diff,end,start);
diff = myddas_stats_time_copy_to_final(diff);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_GET_DB_ROW_FUNCTION(total_time);
myddas_stats_add_time(total_time,diff,total_time);
MYDDAS_STATS_GET_DB_ROW_FUNCTION_COUNT(count);
MYDDAS_STATS_SET_DB_ROW_FUNCTION_COUNT(++count);
MYDDAS_FREE(diff,struct myddas_stats_time_struct);
#endif /* MYDDAS_STATS */
} return rc;
}
#else
void Yap_InitMYDDAS_PGPreds(void);
void Yap_InitBackMYDDAS_PGPreds(void);
void Yap_InitMYDDAS_PGPreds(void)
{
}
void Yap_InitBackMYDDAS_PGPreds(void)
{
}
#endif
void init_pg( void )
{
Yap_InitMYDDAS_PGPreds();
Yap_InitBackMYDDAS_PGPreds();
}
#ifdef _WIN32
#include <windows.h>
int WINAPI win_pg(HANDLE hinst, DWORD reason, LPVOID reserved);
int WINAPI win_pg(HANDLE hinst, DWORD reason, LPVOID reserved) {
switch (reason) {
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
}
return 1;
}
#endif
|
the_stack_data/43886535.c | extern const unsigned char AWSSQSVersionString[];
extern const double AWSSQSVersionNumber;
const unsigned char AWSSQSVersionString[] __attribute__ ((used)) = "@(#)PROGRAM:AWSSQS PROJECT:AWS-1" "\n";
const double AWSSQSVersionNumber __attribute__ ((used)) = (double)1.;
|
the_stack_data/68888690.c | /******************************************************************************
* Intel Management Engine Interface (Intel MEI) Linux driver
* Intel MEI Interface Header
*
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* GPL LICENSE SUMMARY
*
* Copyright(c) 2012 Intel Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
* USA
*
* The full GNU General Public License is included in this distribution
* in the file called LICENSE.GPL.
*
* Contact Information:
* Intel Corporation.
* [email protected]
* http://www.intel.com
*
* BSD LICENSE
*
* Copyright(c) 2003 - 2012 Intel Corporation. All rights reserved.
* 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 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 COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <errno.h>
#include <stdint.h>
#include <stdbool.h>
#include <bits/wordsize.h>
#include <linux/mei.h>
/*****************************************************************************
* Intel Management Engine Interface
*****************************************************************************/
#define mei_msg(_me, fmt, ARGS...) do { \
if (_me->verbose) \
fprintf(stderr, fmt, ##ARGS); \
} while (0)
#define mei_err(_me, fmt, ARGS...) do { \
fprintf(stderr, "Error: " fmt, ##ARGS); \
} while (0)
struct mei {
uuid_le guid;
bool initialized;
bool verbose;
unsigned int buf_size;
unsigned char prot_ver;
int fd;
};
static void mei_deinit(struct mei *cl)
{
if (cl->fd != -1)
close(cl->fd);
cl->fd = -1;
cl->buf_size = 0;
cl->prot_ver = 0;
cl->initialized = false;
}
static bool mei_init(struct mei *me, const uuid_le *guid,
unsigned char req_protocol_version, bool verbose)
{
int result;
struct mei_client *cl;
struct mei_connect_client_data data;
me->verbose = verbose;
me->fd = open("/dev/mei", O_RDWR);
if (me->fd == -1) {
mei_err(me, "Cannot establish a handle to the Intel MEI driver\n");
goto err;
}
memcpy(&me->guid, guid, sizeof(*guid));
memset(&data, 0, sizeof(data));
me->initialized = true;
memcpy(&data.in_client_uuid, &me->guid, sizeof(me->guid));
result = ioctl(me->fd, IOCTL_MEI_CONNECT_CLIENT, &data);
if (result) {
mei_err(me, "IOCTL_MEI_CONNECT_CLIENT receive message. err=%d\n", result);
goto err;
}
cl = &data.out_client_properties;
mei_msg(me, "max_message_length %d\n", cl->max_msg_length);
mei_msg(me, "protocol_version %d\n", cl->protocol_version);
if ((req_protocol_version > 0) &&
(cl->protocol_version != req_protocol_version)) {
mei_err(me, "Intel MEI protocol version not supported\n");
goto err;
}
me->buf_size = cl->max_msg_length;
me->prot_ver = cl->protocol_version;
return true;
err:
mei_deinit(me);
return false;
}
static ssize_t mei_recv_msg(struct mei *me, unsigned char *buffer,
ssize_t len, unsigned long timeout)
{
ssize_t rc;
mei_msg(me, "call read length = %zd\n", len);
rc = read(me->fd, buffer, len);
if (rc < 0) {
mei_err(me, "read failed with status %zd %s\n",
rc, strerror(errno));
mei_deinit(me);
} else {
mei_msg(me, "read succeeded with result %zd\n", rc);
}
return rc;
}
static ssize_t mei_send_msg(struct mei *me, const unsigned char *buffer,
ssize_t len, unsigned long timeout)
{
struct timeval tv;
ssize_t written;
ssize_t rc;
fd_set set;
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000000;
mei_msg(me, "call write length = %zd\n", len);
written = write(me->fd, buffer, len);
if (written < 0) {
rc = -errno;
mei_err(me, "write failed with status %zd %s\n",
written, strerror(errno));
goto out;
}
FD_ZERO(&set);
FD_SET(me->fd, &set);
rc = select(me->fd + 1 , &set, NULL, NULL, &tv);
if (rc > 0 && FD_ISSET(me->fd, &set)) {
mei_msg(me, "write success\n");
} else if (rc == 0) {
mei_err(me, "write failed on timeout with status\n");
goto out;
} else { /* rc < 0 */
mei_err(me, "write failed on select with status %zd\n", rc);
goto out;
}
rc = written;
out:
if (rc < 0)
mei_deinit(me);
return rc;
}
/***************************************************************************
* Intel Advanced Management Technology ME Client
***************************************************************************/
#define AMT_MAJOR_VERSION 1
#define AMT_MINOR_VERSION 1
#define AMT_STATUS_SUCCESS 0x0
#define AMT_STATUS_INTERNAL_ERROR 0x1
#define AMT_STATUS_NOT_READY 0x2
#define AMT_STATUS_INVALID_AMT_MODE 0x3
#define AMT_STATUS_INVALID_MESSAGE_LENGTH 0x4
#define AMT_STATUS_HOST_IF_EMPTY_RESPONSE 0x4000
#define AMT_STATUS_SDK_RESOURCES 0x1004
#define AMT_BIOS_VERSION_LEN 65
#define AMT_VERSIONS_NUMBER 50
#define AMT_UNICODE_STRING_LEN 20
struct amt_unicode_string {
uint16_t length;
char string[AMT_UNICODE_STRING_LEN];
} __attribute__((packed));
struct amt_version_type {
struct amt_unicode_string description;
struct amt_unicode_string version;
} __attribute__((packed));
struct amt_version {
uint8_t major;
uint8_t minor;
} __attribute__((packed));
struct amt_code_versions {
uint8_t bios[AMT_BIOS_VERSION_LEN];
uint32_t count;
struct amt_version_type versions[AMT_VERSIONS_NUMBER];
} __attribute__((packed));
/***************************************************************************
* Intel Advanced Management Technology Host Interface
***************************************************************************/
struct amt_host_if_msg_header {
struct amt_version version;
uint16_t _reserved;
uint32_t command;
uint32_t length;
} __attribute__((packed));
struct amt_host_if_resp_header {
struct amt_host_if_msg_header header;
uint32_t status;
unsigned char data[0];
} __attribute__((packed));
const uuid_le MEI_IAMTHIF = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d, \
0xac, 0xa8, 0x46, 0xe0, 0xff, 0x65, 0x81, 0x4c);
#define AMT_HOST_IF_CODE_VERSIONS_REQUEST 0x0400001A
#define AMT_HOST_IF_CODE_VERSIONS_RESPONSE 0x0480001A
const struct amt_host_if_msg_header CODE_VERSION_REQ = {
.version = {AMT_MAJOR_VERSION, AMT_MINOR_VERSION},
._reserved = 0,
.command = AMT_HOST_IF_CODE_VERSIONS_REQUEST,
.length = 0
};
struct amt_host_if {
struct mei mei_cl;
unsigned long send_timeout;
bool initialized;
};
static bool amt_host_if_init(struct amt_host_if *acmd,
unsigned long send_timeout, bool verbose)
{
acmd->send_timeout = (send_timeout) ? send_timeout : 20000;
acmd->initialized = mei_init(&acmd->mei_cl, &MEI_IAMTHIF, 0, verbose);
return acmd->initialized;
}
static void amt_host_if_deinit(struct amt_host_if *acmd)
{
mei_deinit(&acmd->mei_cl);
acmd->initialized = false;
}
static uint32_t amt_verify_code_versions(const struct amt_host_if_resp_header *resp)
{
uint32_t status = AMT_STATUS_SUCCESS;
struct amt_code_versions *code_ver;
size_t code_ver_len;
uint32_t ver_type_cnt;
uint32_t len;
uint32_t i;
code_ver = (struct amt_code_versions *)resp->data;
/* length - sizeof(status) */
code_ver_len = resp->header.length - sizeof(uint32_t);
ver_type_cnt = code_ver_len -
sizeof(code_ver->bios) -
sizeof(code_ver->count);
if (code_ver->count != ver_type_cnt / sizeof(struct amt_version_type)) {
status = AMT_STATUS_INTERNAL_ERROR;
goto out;
}
for (i = 0; i < code_ver->count; i++) {
len = code_ver->versions[i].description.length;
if (len > AMT_UNICODE_STRING_LEN) {
status = AMT_STATUS_INTERNAL_ERROR;
goto out;
}
len = code_ver->versions[i].version.length;
if (code_ver->versions[i].version.string[len] != '\0' ||
len != strlen(code_ver->versions[i].version.string)) {
status = AMT_STATUS_INTERNAL_ERROR;
goto out;
}
}
out:
return status;
}
static uint32_t amt_verify_response_header(uint32_t command,
const struct amt_host_if_msg_header *resp_hdr,
uint32_t response_size)
{
if (response_size < sizeof(struct amt_host_if_resp_header)) {
return AMT_STATUS_INTERNAL_ERROR;
} else if (response_size != (resp_hdr->length +
sizeof(struct amt_host_if_msg_header))) {
return AMT_STATUS_INTERNAL_ERROR;
} else if (resp_hdr->command != command) {
return AMT_STATUS_INTERNAL_ERROR;
} else if (resp_hdr->_reserved != 0) {
return AMT_STATUS_INTERNAL_ERROR;
} else if (resp_hdr->version.major != AMT_MAJOR_VERSION ||
resp_hdr->version.minor < AMT_MINOR_VERSION) {
return AMT_STATUS_INTERNAL_ERROR;
}
return AMT_STATUS_SUCCESS;
}
static uint32_t amt_host_if_call(struct amt_host_if *acmd,
const unsigned char *command, ssize_t command_sz,
uint8_t **read_buf, uint32_t rcmd,
unsigned int expected_sz)
{
uint32_t in_buf_sz;
uint32_t out_buf_sz;
ssize_t written;
uint32_t status;
struct amt_host_if_resp_header *msg_hdr;
in_buf_sz = acmd->mei_cl.buf_size;
*read_buf = (uint8_t *)malloc(sizeof(uint8_t) * in_buf_sz);
if (*read_buf == NULL)
return AMT_STATUS_SDK_RESOURCES;
memset(*read_buf, 0, in_buf_sz);
msg_hdr = (struct amt_host_if_resp_header *)*read_buf;
written = mei_send_msg(&acmd->mei_cl,
command, command_sz, acmd->send_timeout);
if (written != command_sz)
return AMT_STATUS_INTERNAL_ERROR;
out_buf_sz = mei_recv_msg(&acmd->mei_cl, *read_buf, in_buf_sz, 2000);
if (out_buf_sz <= 0)
return AMT_STATUS_HOST_IF_EMPTY_RESPONSE;
status = msg_hdr->status;
if (status != AMT_STATUS_SUCCESS)
return status;
status = amt_verify_response_header(rcmd,
&msg_hdr->header, out_buf_sz);
if (status != AMT_STATUS_SUCCESS)
return status;
if (expected_sz && expected_sz != out_buf_sz)
return AMT_STATUS_INTERNAL_ERROR;
return AMT_STATUS_SUCCESS;
}
static uint32_t amt_get_code_versions(struct amt_host_if *cmd,
struct amt_code_versions *versions)
{
struct amt_host_if_resp_header *response = NULL;
uint32_t status;
status = amt_host_if_call(cmd,
(const unsigned char *)&CODE_VERSION_REQ,
sizeof(CODE_VERSION_REQ),
(uint8_t **)&response,
AMT_HOST_IF_CODE_VERSIONS_RESPONSE, 0);
if (status != AMT_STATUS_SUCCESS)
goto out;
status = amt_verify_code_versions(response);
if (status != AMT_STATUS_SUCCESS)
goto out;
memcpy(versions, response->data, sizeof(struct amt_code_versions));
out:
if (response != NULL)
free(response);
return status;
}
/************************** end of amt_host_if_command ***********************/
int main(int argc, char **argv)
{
struct amt_code_versions ver;
struct amt_host_if acmd;
unsigned int i;
uint32_t status;
int ret;
bool verbose;
verbose = (argc > 1 && strcmp(argv[1], "-v") == 0);
if (!amt_host_if_init(&acmd, 5000, verbose)) {
ret = 1;
goto out;
}
status = amt_get_code_versions(&acmd, &ver);
amt_host_if_deinit(&acmd);
switch (status) {
case AMT_STATUS_HOST_IF_EMPTY_RESPONSE:
printf("Intel AMT: DISABLED\n");
ret = 0;
break;
case AMT_STATUS_SUCCESS:
printf("Intel AMT: ENABLED\n");
for (i = 0; i < ver.count; i++) {
printf("%s:\t%s\n", ver.versions[i].description.string,
ver.versions[i].version.string);
}
ret = 0;
break;
default:
printf("An error has occurred\n");
ret = 1;
break;
}
out:
return ret;
}
|
the_stack_data/68887686.c | /**
7.6.
1
2 3
3 4 5
4 5 6 7
5 6 7 8 9
*/
#include <stdio.h>
int main(int argc, char const *argv[])
{
int n;
printf("Enter the value of n - ");
scanf("%d", &n);
printf("\n\n");
for (int r = 1; r <= n; r++) {
for (int c = 1; c <= r; c++) {
printf("%d ", r + c - 1);
}
printf("\n");
}
return 0;
}
|
the_stack_data/775783.c | /*
* Copyright (c) 2013 Jonas 'Sortie' Termansen.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* grp/getgrgid.c
* Searchs the group database for a group with the given numeric group id in a
* thread-insecure manner.
*/
#include <errno.h>
#include <grp.h>
#include <stdlib.h>
struct group* getgrgid(gid_t gid)
{
static struct group result_object;
static char* buf = NULL;
static size_t buflen = 0;
if ( !buf )
{
size_t new_buflen = 64;
if ( !(buf = (char*) malloc(new_buflen)) )
return NULL;
buflen = new_buflen;
}
struct group* result;
int errnum;
retry:
errnum = getgrgid_r(gid, &result_object, buf, buflen, &result);
if ( errnum == ERANGE )
{
size_t new_buflen = 2 * buflen;
char* new_buf = (char*) realloc(buf, new_buflen);
if ( !new_buf )
return NULL;
buf = new_buf;
buflen = new_buflen;
goto retry;
}
if ( errnum < 0 )
return errno = errnum, (struct group*) NULL;
return result;
}
|
the_stack_data/3261595.c | #include <assert.h>
int array[] = {1, 2, 3};
int *p;
int *q;
void initialize()
{
p = &(array[1]);
q = array + 1;
array[0] = 4;
}
void checkpoint()
{
}
int main()
{
initialize();
checkpoint();
assert(p == &(array[1]));
assert(p == q);
assert(*p == *q);
assert(array[0] != *p);
*p = 4;
assert(array[0] == *p);
}
|
the_stack_data/34848.c | int main()
{
int i, a, b,c;
a = 0;
b = 1;
c = 2;
for(i=0; i<10; i++)
if (1)
a = b;
return a+c;
}
|
the_stack_data/5085.c | #include <wchar.h>
size_t wcsspn(const wchar_t *s, const wchar_t *c)
{
const wchar_t *a;
for (a=s; *s && wcschr(c, *s); s++);
return s-a;
}
|
the_stack_data/155433.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]/Cd(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;
/* > \brief \b ZLA_GBRCOND_X computes the infinity norm condition number of op(A)*diag(x) for general banded m
atrices. */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* > \htmlonly */
/* > Download ZLA_GBRCOND_X + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zla_gbr
cond_x.f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zla_gbr
cond_x.f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zla_gbr
cond_x.f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */
/* Definition: */
/* =========== */
/* DOUBLE PRECISION FUNCTION ZLA_GBRCOND_X( TRANS, N, KL, KU, AB, */
/* LDAB, AFB, LDAFB, IPIV, */
/* X, INFO, WORK, RWORK ) */
/* CHARACTER TRANS */
/* INTEGER N, KL, KU, KD, KE, LDAB, LDAFB, INFO */
/* INTEGER IPIV( * ) */
/* COMPLEX*16 AB( LDAB, * ), AFB( LDAFB, * ), WORK( * ), */
/* $ X( * ) */
/* DOUBLE PRECISION RWORK( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > ZLA_GBRCOND_X Computes the infinity norm condition number of */
/* > op(A) * diag(X) where X is a COMPLEX*16 vector. */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] TRANS */
/* > \verbatim */
/* > TRANS is CHARACTER*1 */
/* > Specifies the form of the system of equations: */
/* > = 'N': A * X = B (No transpose) */
/* > = 'T': A**T * X = B (Transpose) */
/* > = 'C': A**H * X = B (Conjugate Transpose = Transpose) */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The number of linear equations, i.e., the order of the */
/* > matrix A. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] KL */
/* > \verbatim */
/* > KL is INTEGER */
/* > The number of subdiagonals within the band of A. KL >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] KU */
/* > \verbatim */
/* > KU is INTEGER */
/* > The number of superdiagonals within the band of A. KU >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] AB */
/* > \verbatim */
/* > AB is COMPLEX*16 array, dimension (LDAB,N) */
/* > On entry, the matrix A in band storage, in rows 1 to KL+KU+1. */
/* > The j-th column of A is stored in the j-th column of the */
/* > array AB as follows: */
/* > AB(KU+1+i-j,j) = A(i,j) for f2cmax(1,j-KU)<=i<=f2cmin(N,j+kl) */
/* > \endverbatim */
/* > */
/* > \param[in] LDAB */
/* > \verbatim */
/* > LDAB is INTEGER */
/* > The leading dimension of the array AB. LDAB >= KL+KU+1. */
/* > \endverbatim */
/* > */
/* > \param[in] AFB */
/* > \verbatim */
/* > AFB is COMPLEX*16 array, dimension (LDAFB,N) */
/* > Details of the LU factorization of the band matrix A, as */
/* > computed by ZGBTRF. U is stored as an upper triangular */
/* > band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, */
/* > and the multipliers used during the factorization are stored */
/* > in rows KL+KU+2 to 2*KL+KU+1. */
/* > \endverbatim */
/* > */
/* > \param[in] LDAFB */
/* > \verbatim */
/* > LDAFB is INTEGER */
/* > The leading dimension of the array AFB. LDAFB >= 2*KL+KU+1. */
/* > \endverbatim */
/* > */
/* > \param[in] IPIV */
/* > \verbatim */
/* > IPIV is INTEGER array, dimension (N) */
/* > The pivot indices from the factorization A = P*L*U */
/* > as computed by ZGBTRF; row i of the matrix was interchanged */
/* > with row IPIV(i). */
/* > \endverbatim */
/* > */
/* > \param[in] X */
/* > \verbatim */
/* > X is COMPLEX*16 array, dimension (N) */
/* > The vector X in the formula op(A) * diag(X). */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: Successful exit. */
/* > i > 0: The ith argument is invalid. */
/* > \endverbatim */
/* > */
/* > \param[out] WORK */
/* > \verbatim */
/* > WORK is COMPLEX*16 array, dimension (2*N). */
/* > Workspace. */
/* > \endverbatim */
/* > */
/* > \param[out] RWORK */
/* > \verbatim */
/* > RWORK is DOUBLE PRECISION array, dimension (N). */
/* > Workspace. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup complex16GBcomputational */
/* ===================================================================== */
doublereal zla_gbrcond_x_(char *trans, integer *n, integer *kl, integer *ku,
doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb,
integer *ipiv, doublecomplex *x, integer *info, doublecomplex *work,
doublereal *rwork)
{
/* System generated locals */
integer ab_dim1, ab_offset, afb_dim1, afb_offset, i__1, i__2, i__3, i__4;
doublereal ret_val, d__1, d__2;
doublecomplex z__1, z__2;
/* Local variables */
integer kase, i__, j;
extern logical lsame_(char *, char *);
integer isave[3];
doublereal anorm;
extern /* Subroutine */ int zlacn2_(integer *, doublecomplex *,
doublecomplex *, doublereal *, integer *, integer *);
integer kd, ke;
extern /* Subroutine */ int xerbla_(char *, integer *, ftnlen);
doublereal ainvnm;
extern /* Subroutine */ int zgbtrs_(char *, integer *, integer *, integer
*, integer *, doublecomplex *, integer *, integer *,
doublecomplex *, integer *, integer *);
doublereal tmp;
logical notrans;
/* -- 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 */
/* ===================================================================== */
/* Parameter adjustments */
ab_dim1 = *ldab;
ab_offset = 1 + ab_dim1 * 1;
ab -= ab_offset;
afb_dim1 = *ldafb;
afb_offset = 1 + afb_dim1 * 1;
afb -= afb_offset;
--ipiv;
--x;
--work;
--rwork;
/* Function Body */
ret_val = 0.;
*info = 0;
notrans = lsame_(trans, "N");
if (! notrans && ! lsame_(trans, "T") && ! lsame_(
trans, "C")) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*kl < 0 || *kl > *n - 1) {
*info = -3;
} else if (*ku < 0 || *ku > *n - 1) {
*info = -4;
} else if (*ldab < *kl + *ku + 1) {
*info = -6;
} else if (*ldafb < (*kl << 1) + *ku + 1) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZLA_GBRCOND_X", &i__1, (ftnlen)13);
return ret_val;
}
/* Compute norm of op(A)*op2(C). */
kd = *ku + 1;
ke = *kl + 1;
anorm = 0.;
if (notrans) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
tmp = 0.;
/* Computing MAX */
i__2 = i__ - *kl;
/* Computing MIN */
i__4 = i__ + *ku;
i__3 = f2cmin(i__4,*n);
for (j = f2cmax(i__2,1); j <= i__3; ++j) {
i__2 = kd + i__ - j + j * ab_dim1;
i__4 = j;
z__2.r = ab[i__2].r * x[i__4].r - ab[i__2].i * x[i__4].i,
z__2.i = ab[i__2].r * x[i__4].i + ab[i__2].i * x[i__4]
.r;
z__1.r = z__2.r, z__1.i = z__2.i;
tmp += (d__1 = z__1.r, abs(d__1)) + (d__2 = d_imag(&z__1),
abs(d__2));
}
rwork[i__] = tmp;
anorm = f2cmax(anorm,tmp);
}
} else {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
tmp = 0.;
/* Computing MAX */
i__3 = i__ - *kl;
/* Computing MIN */
i__4 = i__ + *ku;
i__2 = f2cmin(i__4,*n);
for (j = f2cmax(i__3,1); j <= i__2; ++j) {
i__3 = ke - i__ + j + i__ * ab_dim1;
i__4 = j;
z__2.r = ab[i__3].r * x[i__4].r - ab[i__3].i * x[i__4].i,
z__2.i = ab[i__3].r * x[i__4].i + ab[i__3].i * x[i__4]
.r;
z__1.r = z__2.r, z__1.i = z__2.i;
tmp += (d__1 = z__1.r, abs(d__1)) + (d__2 = d_imag(&z__1),
abs(d__2));
}
rwork[i__] = tmp;
anorm = f2cmax(anorm,tmp);
}
}
/* Quick return if possible. */
if (*n == 0) {
ret_val = 1.;
return ret_val;
} else if (anorm == 0.) {
return ret_val;
}
/* Estimate the norm of inv(op(A)). */
ainvnm = 0.;
kase = 0;
L10:
zlacn2_(n, &work[*n + 1], &work[1], &ainvnm, &kase, isave);
if (kase != 0) {
if (kase == 2) {
/* Multiply by R. */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = i__;
i__3 = i__;
i__4 = i__;
z__1.r = rwork[i__4] * work[i__3].r, z__1.i = rwork[i__4] *
work[i__3].i;
work[i__2].r = z__1.r, work[i__2].i = z__1.i;
}
if (notrans) {
zgbtrs_("No transpose", n, kl, ku, &c__1, &afb[afb_offset],
ldafb, &ipiv[1], &work[1], n, info);
} else {
zgbtrs_("Conjugate transpose", n, kl, ku, &c__1, &afb[
afb_offset], ldafb, &ipiv[1], &work[1], n, info);
}
/* Multiply by inv(X). */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = i__;
z_div(&z__1, &work[i__], &x[i__]);
work[i__2].r = z__1.r, work[i__2].i = z__1.i;
}
} else {
/* Multiply by inv(X**H). */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = i__;
z_div(&z__1, &work[i__], &x[i__]);
work[i__2].r = z__1.r, work[i__2].i = z__1.i;
}
if (notrans) {
zgbtrs_("Conjugate transpose", n, kl, ku, &c__1, &afb[
afb_offset], ldafb, &ipiv[1], &work[1], n, info);
} else {
zgbtrs_("No transpose", n, kl, ku, &c__1, &afb[afb_offset],
ldafb, &ipiv[1], &work[1], n, info);
}
/* Multiply by R. */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = i__;
i__3 = i__;
i__4 = i__;
z__1.r = rwork[i__4] * work[i__3].r, z__1.i = rwork[i__4] *
work[i__3].i;
work[i__2].r = z__1.r, work[i__2].i = z__1.i;
}
}
goto L10;
}
/* Compute the estimate of the reciprocal condition number. */
if (ainvnm != 0.) {
ret_val = 1. / ainvnm;
}
return ret_val;
} /* zla_gbrcond_x__ */
|
the_stack_data/72013259.c | /* $NetBSD: qfont.c,v 1.4 1999/06/20 17:58:57 ragge Exp $ */
/*-
* Copyright (c) 1982, 1986
* The Regents of the University of California. All rights reserved.
* (c) UNIX System Laboratories, Inc.
* All or some portions of this file are derived from material licensed
* to the University of California by American Telephone and Telegraph
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
* the permission of UNIX System Laboratories, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)qfont.c 7.2 (Berkeley) 1/21/94
*/
/*
* derived from: "@(#)qfont.c 6.2 ULTRIX 2/4/88"
*/
/************************************************************************
* *
* Copyright (c) 1984, 1987 by *
* Digital Equipment Corporation, Maynard, MA *
* All rights reserved. *
* *
* This software is furnished under a license and may be used and *
* copied only in accordance with the terms of such license and *
* with the inclusion of the above copyright notice. This *
* software or any other copies thereof may not be provided or *
* otherwise made available to any other person. No title to and *
* ownership of the software is hereby transferred. *
* *
* This software is derived from software received from the *
* University of California, Berkeley, and from Bell *
* Laboratories. Use, duplication, or disclosure is subject to *
* restrictions under license agreements with University of *
* California and with AT&T. *
* *
* The information in this software is subject to change without *
* notice and should not be construed as a commitment by Digital *
* Equipment Corporation. *
* *
* Digital assumes no responsibility for the use or reliability *
* of its software on equipment which is not supplied by Digital. *
* *
************************************************************************/
/*
* The following tables are used to translate LK201 key strokes
* into ascii characters. The tables also support the special
* function keys.
*/
unsigned short q_key[]={
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 0 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 8 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 16 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 24 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 32 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 40 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 48 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 56 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 64 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 72 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x101 ,0x102 /* 80 */
,0x103 ,0x104 ,0x105 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 88 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x106 ,0x107 ,0x108 ,0x109 /* 96 */
,0x10a ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 104 */
,0x00 ,0x1b ,0x08 ,0x0a ,0x10b ,0x00 ,0x00 ,0x00 /* 112 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x10c ,0x10d ,0x00 ,0x00 /* 120 */
,0x10e ,0x10f ,0x110 ,0x111 ,0x00 ,0x00 ,0x00 ,0x00 /* 128 */
,0x00 ,0x00 ,0x112 ,0x113 ,0x114 ,0x115 ,0x116 ,0x117 /* 136 */
,0x00 ,0x00 ,0x120 ,0x00 ,0x121 ,0x122 ,0x123 ,0x124 /* 144 */
,0x125 ,0x126 ,0x127 ,0x128 ,0x129 ,0x12a ,0x12b ,0x12c /* 152 */
,0x12d ,0x118 ,0x119 ,0x11a ,0x11b ,0x00 ,0x00 ,0x11c /* 160 */
,0x11d ,0x11e ,0x11f ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 168 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 176 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x7f ,'\r' ,0x09 ,'`' /* 184 */
,'1' ,'q' ,'a' ,'z' ,0x00 ,'2' ,'w' ,'s' /* 192 */
,'x' ,'<' ,0x00 ,'3' ,'e' ,'d' ,'c' ,0x00 /* 200 */
,'4' ,'r' ,'f' ,'v' ,' ' ,0x00 ,'5' ,'t' /* 208 */
,'g' ,'b' ,0x00 ,'6' ,'y' ,'h' ,'n' ,0x00 /* 216 */
,'7' ,'u' ,'j' ,'m' ,0x00 ,'8' ,'i' ,'k' /* 224 */
,',' ,0x00 ,'9' ,'o' ,'l' ,'.' ,0x00 ,'0' /* 232 */
,'p' ,0x00 ,';' ,'/' ,0x00 ,'=' ,']' ,'\\' /* 240 */
,0x00 ,'-' ,'[' ,'\'' ,0x00 ,0x00 ,0x00 ,0x00 /* 248 */
};
unsigned short q_shift_key[]={
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 0 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 8 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 16 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 24 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 32 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 40 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 48 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 56 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 64 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 72 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x101 ,0x102 /* 80 */
,0x103 ,0x104 ,0x105 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 88 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x106 ,0x107 ,0x108 ,0x109 /* 96 */
,0x10a ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 104 */
,0x00 ,0x1b ,0x08 ,0x0a ,0x10b ,0x00 ,0x00 ,0x00 /* 112 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x10c ,0x10d ,0x00 ,0x00 /* 120 */
,0x10e ,0x10f ,0x110 ,0x111 ,0x00 ,0x00 ,0x00 ,0x00 /* 128 */
,0x00 ,0x00 ,0x112 ,0x113 ,0x114 ,0x115 ,0x116 ,0x117 /* 136 */
,0x00 ,0x00 ,0x120 ,0x00 ,0x121 ,0x122 ,0x123 ,0x124 /* 144 */
,0x125 ,0x126 ,0x127 ,0x128 ,0x129 ,0x12a ,0x12b ,0x12c /* 152 */
,0x12d ,0x118 ,0x119 ,0x11a ,0x11b ,0x00 ,0x00 ,0x11c /* 160 */
,0x11d ,0x11e ,0x11f ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 168 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00 /* 176 */
,0x00 ,0x00 ,0x00 ,0x00 ,0x7f ,'\r' ,0x09 ,'~' /* 184 */
,'!' ,'Q' ,'A' ,'Z' ,0x00 ,'@' ,'W' ,'S' /* 192 */
,'X' ,'>' ,0x00 ,'#' ,'E' ,'D' ,'C' ,0x00 /* 200 */
,'$' ,'R' ,'F' ,'V' ,' ' ,0x00 ,'%' ,'T' /* 208 */
,'G' ,'B' ,0x00 ,'^' ,'Y' ,'H' ,'N' ,0x00 /* 216 */
,'&' ,'U' ,'J' ,'M' ,0x00 ,'*' ,'I' ,'K' /* 224 */
,',' ,0x00 ,'(' ,'O' ,'L' ,'.' ,0x00 ,')' /* 232 */
,'P' ,0x00 ,':' ,'?' ,0x00 ,'+' ,'}' ,'|' /* 240 */
,0x00 ,'_' ,'{' ,'"' ,0x00 ,0x00 ,0x00 ,0x00 /* 248 */
};
/*
* LK201 special purpose keys. Translations from the tables above
* includes codes for the function keys and other goodies. They can
* be determined by the presence of the 8th bit being set. The
* following table is accessed by removing that bit and using the
* result as the index to the following table. Note that table begins
* a null entry.
*/
char *q_special[]={ 0,
"\33[11~", /* f1 */
"\33[12~", /* f2 */
"\33[13~", /* f3 */
"\33[14~", /* f4 */
"\33[15~", /* f5 */
"\33[17~", /* f6 */
"\33[18~", /* f7 */
"\33[19~", /* f8 */
"\33[20~", /* f9 */
"\33[21~", /* f10 */
"\33[26~", /* f14 */
"\33[28~", /* f15 */
"\33[29~", /* f16 */
"\33[31~", /* f17 */
"\33[32~", /* f18 */
"\33[33~", /* f19 */
"\33[34~", /* f20 */
"\33[1~", /* find */
"\33[2~", /* insert */
"\33[3~", /* remove */
"\33[4~", /* select */
"\33[5~", /* prev */
"\33[6~", /* next */
"\33OP", /* pf1 */
"\33OQ", /* pf2 */
"\33OR", /* pf3 */
"\33OS", /* pf4 */
"\33[D", /* left */
"\33[C", /* right */
"\33[B", /* down */
"\33[A", /* up */
"\33Op", /* key pad 0 */
"\33On", /* key pad . */
"\33OM", /* key pad enter */
"\33Oq", /* key pad 1 */
"\33Or", /* key pad 2 */
"\33Os", /* key pad 3 */
"\33Ot", /* key pad 4 */
"\33Ou", /* key pad 5 */
"\33Ov", /* key pad 6 */
"\33O/*", /* key pad , */
"\33Ow", /* key pad 7 */
"\33Ox", /* key pad 8 */
"\33Oy", /* key pad 9 */
"\33Om", /* key pad - */
/*
* The following strings are to allow a numeric keypad
* mode and still use the same translation tables
*/
"0",
".",
"\r",
"1",
"2",
"3",
"4",
"5",
"6",
",",
"7",
"8",
"9",
"-"
};
/*
* QVSS font table of displayable characters.
*/
char q_font[]={
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
0x00, /* 0x00000000 */
/* */
0x00, /* 0x00000000 ! */
0x00, /* 0x00000000 ! */
0x08, /* 0x00001000 ! */
0x08, /* 0x00001000 ! */
0x08, /* 0x00001000 ! */
0x08, /* 0x00001000 ! */
0x08, /* 0x00001000 ! */
0x08, /* 0x00001000 ! */
0x08, /* 0x00001000 ! */
0x08, /* 0x00001000 ! */
0x00, /* 0x00000000 ! */
0x08, /* 0x00001000 ! */
0x00, /* 0x00000000 ! */
0x00, /* 0x00000000 ! */
0x00, /* 0x00000000 ! */
/* */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x24, /* 0x00100100 " */
0x24, /* 0x00100100 " */
0x24, /* 0x00100100 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
0x00, /* 0x00000000 " */
/* */
0x00, /* 0x00000000 # */
0x00, /* 0x00000000 # */
0x00, /* 0x00000000 # */
0x12, /* 0x00010010 # */
0x12, /* 0x00010010 # */
0x3f, /* 0x00111111 # */
0x12, /* 0x00010010 # */
0x12, /* 0x00010010 # */
0x3f, /* 0x00111111 # */
0x12, /* 0x00010010 # */
0x12, /* 0x00010010 # */
0x00, /* 0x00000000 # */
0x00, /* 0x00000000 # */
0x00, /* 0x00000000 # */
0x00, /* 0x00000000 # */
/* */
0x00, /* 0x00000000 $ */
0x00, /* 0x00000000 $ */
0x00, /* 0x00000000 $ */
0x08, /* 0x00001000 $ */
0x3e, /* 0x00111110 $ */
0x09, /* 0x00001001 $ */
0x09, /* 0x00001001 $ */
0x3e, /* 0x00111110 $ */
0x48, /* 0x01001000 $ */
0x48, /* 0x01001000 $ */
0x3e, /* 0x00111110 $ */
0x08, /* 0x00001000 $ */
0x00, /* 0x00000000 $ */
0x00, /* 0x00000000 $ */
0x00, /* 0x00000000 $ */
/* */
0x00, /* 0x00000000 % */
0x00, /* 0x00000000 % */
0x42, /* 0x01000010 % */
0x25, /* 0x00100101 % */
0x25, /* 0x00100101 % */
0x12, /* 0x00010010 % */
0x08, /* 0x00001000 % */
0x08, /* 0x00001000 % */
0x24, /* 0x00100100 % */
0x52, /* 0x01010010 % */
0x52, /* 0x01010010 % */
0x21, /* 0x00100001 % */
0x00, /* 0x00000000 % */
0x00, /* 0x00000000 % */
0x00, /* 0x00000000 % */
/* */
0x00, /* 0x00000000 & */
0x00, /* 0x00000000 & */
0x0e, /* 0x00001110 & */
0x11, /* 0x00010001 & */
0x11, /* 0x00010001 & */
0x11, /* 0x00010001 & */
0x0e, /* 0x00001110 & */
0x11, /* 0x00010001 & */
0x51, /* 0x01010001 & */
0x21, /* 0x00100001 & */
0x31, /* 0x00110001 & */
0x4e, /* 0x01001110 & */
0x00, /* 0x00000000 & */
0x00, /* 0x00000000 & */
0x00, /* 0x00000000 & */
/* */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x38, /* 0x00111000 ' */
0x18, /* 0x00011000 ' */
0x04, /* 0x00000100 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
0x00, /* 0x00000000 ' */
/* */
0x00, /* 0x00000000 ( */
0x00, /* 0x00000000 ( */
0x10, /* 0x00010000 ( */
0x08, /* 0x00001000 ( */
0x08, /* 0x00001000 ( */
0x04, /* 0x00000100 ( */
0x04, /* 0x00000100 ( */
0x04, /* 0x00000100 ( */
0x04, /* 0x00000100 ( */
0x08, /* 0x00001000 ( */
0x08, /* 0x00001000 ( */
0x10, /* 0x00010000 ( */
0x00, /* 0x00000000 ( */
0x00, /* 0x00000000 ( */
0x00, /* 0x00000000 ( */
/* */
0x00, /* 0x00000000 ) */
0x00, /* 0x00000000 ) */
0x04, /* 0x00000100 ) */
0x08, /* 0x00001000 ) */
0x08, /* 0x00001000 ) */
0x10, /* 0x00010000 ) */
0x10, /* 0x00010000 ) */
0x10, /* 0x00010000 ) */
0x10, /* 0x00010000 ) */
0x08, /* 0x00001000 ) */
0x08, /* 0x00001000 ) */
0x04, /* 0x00000100 ) */
0x00, /* 0x00000000 ) */
0x00, /* 0x00000000 ) */
0x00, /* 0x00000000 ) */
/* */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
0x22, /* 0x00100010 * */
0x14, /* 0x00010100 * */
0x7f, /* 0x01111111 * */
0x14, /* 0x00010100 * */
0x22, /* 0x00100010 * */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
0x00, /* 0x00000000 * */
/* */
0x00, /* 0x00000000 + */
0x00, /* 0x00000000 + */
0x00, /* 0x00000000 + */
0x00, /* 0x00000000 + */
0x08, /* 0x00001000 + */
0x08, /* 0x00001000 + */
0x08, /* 0x00001000 + */
0x7f, /* 0x01111111 + */
0x08, /* 0x00001000 + */
0x08, /* 0x00001000 + */
0x08, /* 0x00001000 + */
0x00, /* 0x00000000 + */
0x00, /* 0x00000000 + */
0x00, /* 0x00000000 + */
0x00, /* 0x00000000 + */
/* */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
0x1c, /* 0x00011100 , */
0x0c, /* 0x00001100 , */
0x02, /* 0x00000010 , */
0x00, /* 0x00000000 , */
0x00, /* 0x00000000 , */
/* */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x7f, /* 0x01111111 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
0x00, /* 0x00000000 - */
/* */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
0x08, /* 0x00001000 . */
0x1c, /* 0x00011100 . */
0x08, /* 0x00001000 . */
0x00, /* 0x00000000 . */
0x00, /* 0x00000000 . */
/* */
0x00, /* 0x00000000 / */
0x00, /* 0x00000000 / */
0x40, /* 0x01000000 / */
0x40, /* 0x01000000 / */
0x20, /* 0x00100000 / */
0x10, /* 0x00010000 / */
0x08, /* 0x00001000 / */
0x04, /* 0x00000100 / */
0x02, /* 0x00000010 / */
0x01, /* 0x00000001 / */
0x01, /* 0x00000001 / */
0x01, /* 0x00000001 / */
0x00, /* 0x00000000 / */
0x00, /* 0x00000000 / */
0x00, /* 0x00000000 / */
/* */
0x00, /* 0x00000000 0 */
0x00, /* 0x00000000 0 */
0x0c, /* 0x00001100 0 */
0x12, /* 0x00010010 0 */
0x21, /* 0x00100001 0 */
0x21, /* 0x00100001 0 */
0x21, /* 0x00100001 0 */
0x21, /* 0x00100001 0 */
0x21, /* 0x00100001 0 */
0x21, /* 0x00100001 0 */
0x12, /* 0x00010010 0 */
0x0c, /* 0x00001100 0 */
0x00, /* 0x00000000 0 */
0x00, /* 0x00000000 0 */
0x00, /* 0x00000000 0 */
/* */
0x00, /* 0x00000000 1 */
0x00, /* 0x00000000 1 */
0x08, /* 0x00001000 1 */
0x0c, /* 0x00001100 1 */
0x0a, /* 0x00001010 1 */
0x08, /* 0x00001000 1 */
0x08, /* 0x00001000 1 */
0x08, /* 0x00001000 1 */
0x08, /* 0x00001000 1 */
0x08, /* 0x00001000 1 */
0x08, /* 0x00001000 1 */
0x3e, /* 0x00111110 1 */
0x00, /* 0x00000000 1 */
0x00, /* 0x00000000 1 */
0x00, /* 0x00000000 1 */
/* */
0x00, /* 0x00000000 2 */
0x00, /* 0x00000000 2 */
0x3e, /* 0x00111110 2 */
0x41, /* 0x01000001 2 */
0x41, /* 0x01000001 2 */
0x40, /* 0x01000000 2 */
0x20, /* 0x00100000 2 */
0x10, /* 0x00010000 2 */
0x0c, /* 0x00001100 2 */
0x02, /* 0x00000010 2 */
0x01, /* 0x00000001 2 */
0x7f, /* 0x01111111 2 */
0x00, /* 0x00000000 2 */
0x00, /* 0x00000000 2 */
0x00, /* 0x00000000 2 */
/* */
0x00, /* 0x00000000 3 */
0x00, /* 0x00000000 3 */
0x7f, /* 0x01111111 3 */
0x40, /* 0x01000000 3 */
0x20, /* 0x00100000 3 */
0x10, /* 0x00010000 3 */
0x38, /* 0x00111000 3 */
0x40, /* 0x01000000 3 */
0x40, /* 0x01000000 3 */
0x40, /* 0x01000000 3 */
0x41, /* 0x01000001 3 */
0x3e, /* 0x00111110 3 */
0x00, /* 0x00000000 3 */
0x00, /* 0x00000000 3 */
0x00, /* 0x00000000 3 */
/* */
0x00, /* 0x00000000 4 */
0x00, /* 0x00000000 4 */
0x20, /* 0x00100000 4 */
0x30, /* 0x00110000 4 */
0x28, /* 0x00101000 4 */
0x24, /* 0x00100100 4 */
0x22, /* 0x00100010 4 */
0x21, /* 0x00100001 4 */
0x7f, /* 0x01111111 4 */
0x20, /* 0x00100000 4 */
0x20, /* 0x00100000 4 */
0x20, /* 0x00100000 4 */
0x00, /* 0x00000000 4 */
0x00, /* 0x00000000 4 */
0x00, /* 0x00000000 4 */
/* */
0x00, /* 0x00000000 5 */
0x00, /* 0x00000000 5 */
0x7f, /* 0x01111111 5 */
0x01, /* 0x00000001 5 */
0x01, /* 0x00000001 5 */
0x3d, /* 0x00111101 5 */
0x43, /* 0x01000011 5 */
0x40, /* 0x01000000 5 */
0x40, /* 0x01000000 5 */
0x40, /* 0x01000000 5 */
0x41, /* 0x01000001 5 */
0x3e, /* 0x00111110 5 */
0x00, /* 0x00000000 5 */
0x00, /* 0x00000000 5 */
0x00, /* 0x00000000 5 */
/* */
0x00, /* 0x00000000 6 */
0x00, /* 0x00000000 6 */
0x3c, /* 0x00111100 6 */
0x02, /* 0x00000010 6 */
0x01, /* 0x00000001 6 */
0x01, /* 0x00000001 6 */
0x3d, /* 0x00111101 6 */
0x43, /* 0x01000011 6 */
0x41, /* 0x01000001 6 */
0x41, /* 0x01000001 6 */
0x41, /* 0x01000001 6 */
0x3e, /* 0x00111110 6 */
0x00, /* 0x00000000 6 */
0x00, /* 0x00000000 6 */
0x00, /* 0x00000000 6 */
/* */
0x00, /* 0x00000000 7 */
0x00, /* 0x00000000 7 */
0x7f, /* 0x01111111 7 */
0x40, /* 0x01000000 7 */
0x40, /* 0x01000000 7 */
0x20, /* 0x00100000 7 */
0x10, /* 0x00010000 7 */
0x08, /* 0x00001000 7 */
0x04, /* 0x00000100 7 */
0x04, /* 0x00000100 7 */
0x02, /* 0x00000010 7 */
0x02, /* 0x00000010 7 */
0x00, /* 0x00000000 7 */
0x00, /* 0x00000000 7 */
0x00, /* 0x00000000 7 */
/* */
0x00, /* 0x00000000 8 */
0x00, /* 0x00000000 8 */
0x3e, /* 0x00111110 8 */
0x41, /* 0x01000001 8 */
0x41, /* 0x01000001 8 */
0x41, /* 0x01000001 8 */
0x3e, /* 0x00111110 8 */
0x41, /* 0x01000001 8 */
0x41, /* 0x01000001 8 */
0x41, /* 0x01000001 8 */
0x41, /* 0x01000001 8 */
0x3e, /* 0x00111110 8 */
0x00, /* 0x00000000 8 */
0x00, /* 0x00000000 8 */
0x00, /* 0x00000000 8 */
/* */
0x00, /* 0x00000000 9 */
0x00, /* 0x00000000 9 */
0x3e, /* 0x00111110 9 */
0x41, /* 0x01000001 9 */
0x41, /* 0x01000001 9 */
0x41, /* 0x01000001 9 */
0x61, /* 0x01100001 9 */
0x5e, /* 0x01011110 9 */
0x40, /* 0x01000000 9 */
0x40, /* 0x01000000 9 */
0x20, /* 0x00100000 9 */
0x1e, /* 0x00011110 9 */
0x00, /* 0x00000000 9 */
0x00, /* 0x00000000 9 */
0x00, /* 0x00000000 9 */
/* */
0x00, /* 0x00000000 : */
0x00, /* 0x00000000 : */
0x00, /* 0x00000000 : */
0x00, /* 0x00000000 : */
0x00, /* 0x00000000 : */
0x08, /* 0x00001000 : */
0x1c, /* 0x00011100 : */
0x08, /* 0x00001000 : */
0x00, /* 0x00000000 : */
0x00, /* 0x00000000 : */
0x08, /* 0x00001000 : */
0x1c, /* 0x00011100 : */
0x08, /* 0x00001000 : */
0x00, /* 0x00000000 : */
0x00, /* 0x00000000 : */
/* */
0x00, /* 0x00000000 ; */
0x00, /* 0x00000000 ; */
0x00, /* 0x00000000 ; */
0x00, /* 0x00000000 ; */
0x00, /* 0x00000000 ; */
0x08, /* 0x00001000 ; */
0x1c, /* 0x00011100 ; */
0x08, /* 0x00001000 ; */
0x00, /* 0x00000000 ; */
0x00, /* 0x00000000 ; */
0x1c, /* 0x00011100 ; */
0x0c, /* 0x00001100 ; */
0x02, /* 0x00000010 ; */
0x00, /* 0x00000000 ; */
0x00, /* 0x00000000 ; */
/* */
0x00, /* 0x00000000 < */
0x00, /* 0x00000000 < */
0x20, /* 0x00100000 < */
0x10, /* 0x00010000 < */
0x08, /* 0x00001000 < */
0x04, /* 0x00000100 < */
0x02, /* 0x00000010 < */
0x02, /* 0x00000010 < */
0x04, /* 0x00000100 < */
0x08, /* 0x00001000 < */
0x10, /* 0x00010000 < */
0x20, /* 0x00100000 < */
0x00, /* 0x00000000 < */
0x00, /* 0x00000000 < */
0x00, /* 0x00000000 < */
/* */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x7f, /* 0x01111111 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x7f, /* 0x01111111 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
0x00, /* 0x00000000 = */
/* */
0x00, /* 0x00000000 > */
0x00, /* 0x00000000 > */
0x02, /* 0x00000010 > */
0x04, /* 0x00000100 > */
0x08, /* 0x00001000 > */
0x10, /* 0x00010000 > */
0x20, /* 0x00100000 > */
0x20, /* 0x00100000 > */
0x10, /* 0x00010000 > */
0x08, /* 0x00001000 > */
0x04, /* 0x00000100 > */
0x02, /* 0x00000010 > */
0x00, /* 0x00000000 > */
0x00, /* 0x00000000 > */
0x00, /* 0x00000000 > */
/* */
0x00, /* 0x00000000 ? */
0x00, /* 0x00000000 ? */
0x3e, /* 0x00111110 ? */
0x41, /* 0x01000001 ? */
0x41, /* 0x01000001 ? */
0x40, /* 0x01000000 ? */
0x20, /* 0x00100000 ? */
0x10, /* 0x00010000 ? */
0x08, /* 0x00001000 ? */
0x08, /* 0x00001000 ? */
0x00, /* 0x00000000 ? */
0x08, /* 0x00001000 ? */
0x00, /* 0x00000000 ? */
0x00, /* 0x00000000 ? */
0x00, /* 0x00000000 ? */
/* */
0x00, /* 0x00000000 @ */
0x00, /* 0x00000000 @ */
0x3e, /* 0x00111110 @ */
0x41, /* 0x01000001 @ */
0x41, /* 0x01000001 @ */
0x79, /* 0x01111001 @ */
0x45, /* 0x01000101 @ */
0x65, /* 0x01100101 @ */
0x59, /* 0x01011001 @ */
0x01, /* 0x00000001 @ */
0x01, /* 0x00000001 @ */
0x3e, /* 0x00111110 @ */
0x00, /* 0x00000000 @ */
0x00, /* 0x00000000 @ */
0x00, /* 0x00000000 @ */
/* */
0x00, /* 0x00000000 A */
0x00, /* 0x00000000 A */
0x08, /* 0x00001000 A */
0x14, /* 0x00010100 A */
0x22, /* 0x00100010 A */
0x41, /* 0x01000001 A */
0x41, /* 0x01000001 A */
0x41, /* 0x01000001 A */
0x7f, /* 0x01111111 A */
0x41, /* 0x01000001 A */
0x41, /* 0x01000001 A */
0x41, /* 0x01000001 A */
0x00, /* 0x00000000 A */
0x00, /* 0x00000000 A */
0x00, /* 0x00000000 A */
/* */
0x00, /* 0x00000000 B */
0x00, /* 0x00000000 B */
0x3f, /* 0x00111111 B */
0x42, /* 0x01000010 B */
0x42, /* 0x01000010 B */
0x42, /* 0x01000010 B */
0x3e, /* 0x00111110 B */
0x42, /* 0x01000010 B */
0x42, /* 0x01000010 B */
0x42, /* 0x01000010 B */
0x42, /* 0x01000010 B */
0x3f, /* 0x00111111 B */
0x00, /* 0x00000000 B */
0x00, /* 0x00000000 B */
0x00, /* 0x00000000 B */
/* */
0x00, /* 0x00000000 C */
0x00, /* 0x00000000 C */
0x3e, /* 0x00111110 C */
0x41, /* 0x01000001 C */
0x01, /* 0x00000001 C */
0x01, /* 0x00000001 C */
0x01, /* 0x00000001 C */
0x01, /* 0x00000001 C */
0x01, /* 0x00000001 C */
0x01, /* 0x00000001 C */
0x41, /* 0x01000001 C */
0x3e, /* 0x00111110 C */
0x00, /* 0x00000000 C */
0x00, /* 0x00000000 C */
0x00, /* 0x00000000 C */
/* */
0x00, /* 0x00000000 D */
0x00, /* 0x00000000 D */
0x3f, /* 0x00111111 D */
0x42, /* 0x01000010 D */
0x42, /* 0x01000010 D */
0x42, /* 0x01000010 D */
0x42, /* 0x01000010 D */
0x42, /* 0x01000010 D */
0x42, /* 0x01000010 D */
0x42, /* 0x01000010 D */
0x42, /* 0x01000010 D */
0x3f, /* 0x00111111 D */
0x00, /* 0x00000000 D */
0x00, /* 0x00000000 D */
0x00, /* 0x00000000 D */
/* */
0x00, /* 0x00000000 E */
0x00, /* 0x00000000 E */
0x7e, /* 0x01111110 E */
0x02, /* 0x00000010 E */
0x02, /* 0x00000010 E */
0x02, /* 0x00000010 E */
0x1e, /* 0x00011110 E */
0x02, /* 0x00000010 E */
0x02, /* 0x00000010 E */
0x02, /* 0x00000010 E */
0x02, /* 0x00000010 E */
0x7e, /* 0x01111110 E */
0x00, /* 0x00000000 E */
0x00, /* 0x00000000 E */
0x00, /* 0x00000000 E */
/* */
0x00, /* 0x00000000 F */
0x00, /* 0x00000000 F */
0x7e, /* 0x01111110 F */
0x02, /* 0x00000010 F */
0x02, /* 0x00000010 F */
0x02, /* 0x00000010 F */
0x1e, /* 0x00011110 F */
0x02, /* 0x00000010 F */
0x02, /* 0x00000010 F */
0x02, /* 0x00000010 F */
0x02, /* 0x00000010 F */
0x02, /* 0x00000010 F */
0x00, /* 0x00000000 F */
0x00, /* 0x00000000 F */
0x00, /* 0x00000000 F */
/* */
0x00, /* 0x00000000 G */
0x00, /* 0x00000000 G */
0x3e, /* 0x00111110 G */
0x41, /* 0x01000001 G */
0x01, /* 0x00000001 G */
0x01, /* 0x00000001 G */
0x01, /* 0x00000001 G */
0x71, /* 0x01110001 G */
0x41, /* 0x01000001 G */
0x41, /* 0x01000001 G */
0x41, /* 0x01000001 G */
0x3e, /* 0x00111110 G */
0x00, /* 0x00000000 G */
0x00, /* 0x00000000 G */
0x00, /* 0x00000000 G */
/* */
0x00, /* 0x00000000 H */
0x00, /* 0x00000000 H */
0x41, /* 0x01000001 H */
0x41, /* 0x01000001 H */
0x41, /* 0x01000001 H */
0x41, /* 0x01000001 H */
0x7f, /* 0x01111111 H */
0x41, /* 0x01000001 H */
0x41, /* 0x01000001 H */
0x41, /* 0x01000001 H */
0x41, /* 0x01000001 H */
0x41, /* 0x01000001 H */
0x00, /* 0x00000000 H */
0x00, /* 0x00000000 H */
0x00, /* 0x00000000 H */
/* */
0x00, /* 0x00000000 I */
0x00, /* 0x00000000 I */
0x3e, /* 0x00111110 I */
0x08, /* 0x00001000 I */
0x08, /* 0x00001000 I */
0x08, /* 0x00001000 I */
0x08, /* 0x00001000 I */
0x08, /* 0x00001000 I */
0x08, /* 0x00001000 I */
0x08, /* 0x00001000 I */
0x08, /* 0x00001000 I */
0x3e, /* 0x00111110 I */
0x00, /* 0x00000000 I */
0x00, /* 0x00000000 I */
0x00, /* 0x00000000 I */
/* */
0x00, /* 0x00000000 J */
0x00, /* 0x00000000 J */
0x78, /* 0x01111000 J */
0x20, /* 0x00100000 J */
0x20, /* 0x00100000 J */
0x20, /* 0x00100000 J */
0x20, /* 0x00100000 J */
0x20, /* 0x00100000 J */
0x20, /* 0x00100000 J */
0x20, /* 0x00100000 J */
0x21, /* 0x00100001 J */
0x1e, /* 0x00011110 J */
0x00, /* 0x00000000 J */
0x00, /* 0x00000000 J */
0x00, /* 0x00000000 J */
/* */
0x00, /* 0x00000000 K */
0x00, /* 0x00000000 K */
0x41, /* 0x01000001 K */
0x21, /* 0x00100001 K */
0x11, /* 0x00010001 K */
0x09, /* 0x00001001 K */
0x07, /* 0x00000111 K */
0x05, /* 0x00000101 K */
0x09, /* 0x00001001 K */
0x11, /* 0x00010001 K */
0x21, /* 0x00100001 K */
0x41, /* 0x01000001 K */
0x00, /* 0x00000000 K */
0x00, /* 0x00000000 K */
0x00, /* 0x00000000 K */
/* */
0x00, /* 0x00000000 L */
0x00, /* 0x00000000 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x01, /* 0x00000001 L */
0x7f, /* 0x01111111 L */
0x00, /* 0x00000000 L */
0x00, /* 0x00000000 L */
0x00, /* 0x00000000 L */
/* */
0x00, /* 0x00000000 M */
0x00, /* 0x00000000 M */
0x41, /* 0x01000001 M */
0x41, /* 0x01000001 M */
0x63, /* 0x01100011 M */
0x55, /* 0x01010101 M */
0x55, /* 0x01010101 M */
0x49, /* 0x01001001 M */
0x49, /* 0x01001001 M */
0x41, /* 0x01000001 M */
0x41, /* 0x01000001 M */
0x41, /* 0x01000001 M */
0x00, /* 0x00000000 M */
0x00, /* 0x00000000 M */
0x00, /* 0x00000000 M */
/* */
0x00, /* 0x00000000 N */
0x00, /* 0x00000000 N */
0x41, /* 0x01000001 N */
0x41, /* 0x01000001 N */
0x43, /* 0x01000011 N */
0x45, /* 0x01000101 N */
0x49, /* 0x01001001 N */
0x51, /* 0x01010001 N */
0x61, /* 0x01100001 N */
0x41, /* 0x01000001 N */
0x41, /* 0x01000001 N */
0x41, /* 0x01000001 N */
0x00, /* 0x00000000 N */
0x00, /* 0x00000000 N */
0x00, /* 0x00000000 N */
/* */
0x00, /* 0x00000000 O */
0x00, /* 0x00000000 O */
0x3e, /* 0x00111110 O */
0x41, /* 0x01000001 O */
0x41, /* 0x01000001 O */
0x41, /* 0x01000001 O */
0x41, /* 0x01000001 O */
0x41, /* 0x01000001 O */
0x41, /* 0x01000001 O */
0x41, /* 0x01000001 O */
0x41, /* 0x01000001 O */
0x3e, /* 0x00111110 O */
0x00, /* 0x00000000 O */
0x00, /* 0x00000000 O */
0x00, /* 0x00000000 O */
/* */
0x00, /* 0x00000000 P */
0x00, /* 0x00000000 P */
0x3f, /* 0x00111111 P */
0x41, /* 0x01000001 P */
0x41, /* 0x01000001 P */
0x41, /* 0x01000001 P */
0x3f, /* 0x00111111 P */
0x01, /* 0x00000001 P */
0x01, /* 0x00000001 P */
0x01, /* 0x00000001 P */
0x01, /* 0x00000001 P */
0x01, /* 0x00000001 P */
0x00, /* 0x00000000 P */
0x00, /* 0x00000000 P */
0x00, /* 0x00000000 P */
/* */
0x00, /* 0x00000000 Q */
0x00, /* 0x00000000 Q */
0x3e, /* 0x00111110 Q */
0x41, /* 0x01000001 Q */
0x41, /* 0x01000001 Q */
0x41, /* 0x01000001 Q */
0x41, /* 0x01000001 Q */
0x41, /* 0x01000001 Q */
0x41, /* 0x01000001 Q */
0x49, /* 0x01001001 Q */
0x51, /* 0x01010001 Q */
0x3e, /* 0x00111110 Q */
0x40, /* 0x01000000 Q */
0x00, /* 0x00000000 Q */
0x00, /* 0x00000000 Q */
/* */
0x00, /* 0x00000000 R */
0x00, /* 0x00000000 R */
0x3f, /* 0x00111111 R */
0x41, /* 0x01000001 R */
0x41, /* 0x01000001 R */
0x41, /* 0x01000001 R */
0x3f, /* 0x00111111 R */
0x09, /* 0x00001001 R */
0x11, /* 0x00010001 R */
0x21, /* 0x00100001 R */
0x41, /* 0x01000001 R */
0x41, /* 0x01000001 R */
0x00, /* 0x00000000 R */
0x00, /* 0x00000000 R */
0x00, /* 0x00000000 R */
/* */
0x00, /* 0x00000000 S */
0x00, /* 0x00000000 S */
0x3e, /* 0x00111110 S */
0x41, /* 0x01000001 S */
0x01, /* 0x00000001 S */
0x01, /* 0x00000001 S */
0x3e, /* 0x00111110 S */
0x40, /* 0x01000000 S */
0x40, /* 0x01000000 S */
0x40, /* 0x01000000 S */
0x41, /* 0x01000001 S */
0x3e, /* 0x00111110 S */
0x00, /* 0x00000000 S */
0x00, /* 0x00000000 S */
0x00, /* 0x00000000 S */
/* */
0x00, /* 0x00000000 T */
0x00, /* 0x00000000 T */
0x7f, /* 0x01111111 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x08, /* 0x00001000 T */
0x00, /* 0x00000000 T */
0x00, /* 0x00000000 T */
0x00, /* 0x00000000 T */
/* */
0x00, /* 0x00000000 U */
0x00, /* 0x00000000 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x41, /* 0x01000001 U */
0x3e, /* 0x00111110 U */
0x00, /* 0x00000000 U */
0x00, /* 0x00000000 U */
0x00, /* 0x00000000 U */
/* */
0x00, /* 0x00000000 V */
0x00, /* 0x00000000 V */
0x41, /* 0x01000001 V */
0x41, /* 0x01000001 V */
0x41, /* 0x01000001 V */
0x22, /* 0x00100010 V */
0x22, /* 0x00100010 V */
0x22, /* 0x00100010 V */
0x14, /* 0x00010100 V */
0x14, /* 0x00010100 V */
0x14, /* 0x00010100 V */
0x08, /* 0x00001000 V */
0x00, /* 0x00000000 V */
0x00, /* 0x00000000 V */
0x00, /* 0x00000000 V */
/* */
0x00, /* 0x00000000 W */
0x00, /* 0x00000000 W */
0x41, /* 0x01000001 W */
0x41, /* 0x01000001 W */
0x41, /* 0x01000001 W */
0x41, /* 0x01000001 W */
0x49, /* 0x01001001 W */
0x49, /* 0x01001001 W */
0x49, /* 0x01001001 W */
0x49, /* 0x01001001 W */
0x55, /* 0x01010101 W */
0x22, /* 0x00100010 W */
0x00, /* 0x00000000 W */
0x00, /* 0x00000000 W */
0x00, /* 0x00000000 W */
/* */
0x00, /* 0x00000000 X */
0x00, /* 0x00000000 X */
0x41, /* 0x01000001 X */
0x41, /* 0x01000001 X */
0x22, /* 0x00100010 X */
0x14, /* 0x00010100 X */
0x08, /* 0x00001000 X */
0x08, /* 0x00001000 X */
0x14, /* 0x00010100 X */
0x22, /* 0x00100010 X */
0x41, /* 0x01000001 X */
0x41, /* 0x01000001 X */
0x00, /* 0x00000000 X */
0x00, /* 0x00000000 X */
0x00, /* 0x00000000 X */
/* */
0x00, /* 0x00000000 Y */
0x00, /* 0x00000000 Y */
0x41, /* 0x01000001 Y */
0x41, /* 0x01000001 Y */
0x22, /* 0x00100010 Y */
0x14, /* 0x00010100 Y */
0x08, /* 0x00001000 Y */
0x08, /* 0x00001000 Y */
0x08, /* 0x00001000 Y */
0x08, /* 0x00001000 Y */
0x08, /* 0x00001000 Y */
0x08, /* 0x00001000 Y */
0x00, /* 0x00000000 Y */
0x00, /* 0x00000000 Y */
0x00, /* 0x00000000 Y */
/* */
0x00, /* 0x00000000 Z */
0x00, /* 0x00000000 Z */
0x7f, /* 0x01111111 Z */
0x40, /* 0x01000000 Z */
0x20, /* 0x00100000 Z */
0x10, /* 0x00010000 Z */
0x08, /* 0x00001000 Z */
0x04, /* 0x00000100 Z */
0x02, /* 0x00000010 Z */
0x01, /* 0x00000001 Z */
0x01, /* 0x00000001 Z */
0x7f, /* 0x01111111 Z */
0x00, /* 0x00000000 Z */
0x00, /* 0x00000000 Z */
0x00, /* 0x00000000 Z */
/* */
0x00, /* 0x00000000 [ */
0x00, /* 0x00000000 [ */
0x3c, /* 0x00111100 [ */
0x04, /* 0x00000100 [ */
0x04, /* 0x00000100 [ */
0x04, /* 0x00000100 [ */
0x04, /* 0x00000100 [ */
0x04, /* 0x00000100 [ */
0x04, /* 0x00000100 [ */
0x04, /* 0x00000100 [ */
0x04, /* 0x00000100 [ */
0x3c, /* 0x00111100 [ */
0x00, /* 0x00000000 [ */
0x00, /* 0x00000000 [ */
0x00, /* 0x00000000 [ */
/* */
0x00, /* 0x00000000 \ */
0x00, /* 0x00000000 \ */
0x01, /* 0x00000001 \ */
0x02, /* 0x00000010 \ */
0x02, /* 0x00000010 \ */
0x04, /* 0x00000100 \ */
0x08, /* 0x00001000 \ */
0x08, /* 0x00001000 \ */
0x10, /* 0x00010000 \ */
0x20, /* 0x00100000 \ */
0x20, /* 0x00100000 \ */
0x40, /* 0x01000000 \ */
0x00, /* 0x00000000 \ */
0x00, /* 0x00000000 \ */
0x00, /* 0x00000000 \ */
/* */
0x00, /* 0x00000000 ] */
0x00, /* 0x00000000 ] */
0x1e, /* 0x00011110 ] */
0x10, /* 0x00010000 ] */
0x10, /* 0x00010000 ] */
0x10, /* 0x00010000 ] */
0x10, /* 0x00010000 ] */
0x10, /* 0x00010000 ] */
0x10, /* 0x00010000 ] */
0x10, /* 0x00010000 ] */
0x10, /* 0x00010000 ] */
0x1e, /* 0x00011110 ] */
0x00, /* 0x00000000 ] */
0x00, /* 0x00000000 ] */
0x00, /* 0x00000000 ] */
/* */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x08, /* 0x00001000 ^ */
0x14, /* 0x00010100 ^ */
0x22, /* 0x00100010 ^ */
0x41, /* 0x01000001 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
0x00, /* 0x00000000 ^ */
/* */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
0x7f, /* 0x01111111 _ */
0x00, /* 0x00000000 _ */
0x00, /* 0x00000000 _ */
/* */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x0e, /* 0x00001110 ` */
0x0c, /* 0x00001100 ` */
0x10, /* 0x00010000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
0x00, /* 0x00000000 ` */
/* */
0x00, /* 0x00000000 a */
0x00, /* 0x00000000 a */
0x00, /* 0x00000000 a */
0x00, /* 0x00000000 a */
0x00, /* 0x00000000 a */
0x3e, /* 0x00111110 a */
0x40, /* 0x01000000 a */
0x40, /* 0x01000000 a */
0x7e, /* 0x01111110 a */
0x41, /* 0x01000001 a */
0x61, /* 0x01100001 a */
0x5e, /* 0x01011110 a */
0x00, /* 0x00000000 a */
0x00, /* 0x00000000 a */
0x00, /* 0x00000000 a */
/* */
0x00, /* 0x00000000 b */
0x00, /* 0x00000000 b */
0x01, /* 0x00000001 b */
0x01, /* 0x00000001 b */
0x01, /* 0x00000001 b */
0x3d, /* 0x00111101 b */
0x43, /* 0x01000011 b */
0x41, /* 0x01000001 b */
0x41, /* 0x01000001 b */
0x41, /* 0x01000001 b */
0x43, /* 0x01000011 b */
0x3d, /* 0x00111101 b */
0x00, /* 0x00000000 b */
0x00, /* 0x00000000 b */
0x00, /* 0x00000000 b */
/* */
0x00, /* 0x00000000 c */
0x00, /* 0x00000000 c */
0x00, /* 0x00000000 c */
0x00, /* 0x00000000 c */
0x00, /* 0x00000000 c */
0x3e, /* 0x00111110 c */
0x41, /* 0x01000001 c */
0x01, /* 0x00000001 c */
0x01, /* 0x00000001 c */
0x01, /* 0x00000001 c */
0x41, /* 0x01000001 c */
0x3e, /* 0x00111110 c */
0x00, /* 0x00000000 c */
0x00, /* 0x00000000 c */
0x00, /* 0x00000000 c */
/* */
0x00, /* 0x00000000 d */
0x00, /* 0x00000000 d */
0x40, /* 0x01000000 d */
0x40, /* 0x01000000 d */
0x40, /* 0x01000000 d */
0x5e, /* 0x01011110 d */
0x61, /* 0x01100001 d */
0x41, /* 0x01000001 d */
0x41, /* 0x01000001 d */
0x41, /* 0x01000001 d */
0x61, /* 0x01100001 d */
0x5e, /* 0x01011110 d */
0x00, /* 0x00000000 d */
0x00, /* 0x00000000 d */
0x00, /* 0x00000000 d */
/* */
0x00, /* 0x00000000 e */
0x00, /* 0x00000000 e */
0x00, /* 0x00000000 e */
0x00, /* 0x00000000 e */
0x00, /* 0x00000000 e */
0x3e, /* 0x00111110 e */
0x41, /* 0x01000001 e */
0x41, /* 0x01000001 e */
0x7f, /* 0x01111111 e */
0x01, /* 0x00000001 e */
0x01, /* 0x00000001 e */
0x3e, /* 0x00111110 e */
0x00, /* 0x00000000 e */
0x00, /* 0x00000000 e */
0x00, /* 0x00000000 e */
/* */
0x00, /* 0x00000000 f */
0x00, /* 0x00000000 f */
0x38, /* 0x00111000 f */
0x44, /* 0x01000100 f */
0x44, /* 0x01000100 f */
0x04, /* 0x00000100 f */
0x04, /* 0x00000100 f */
0x1f, /* 0x00011111 f */
0x04, /* 0x00000100 f */
0x04, /* 0x00000100 f */
0x04, /* 0x00000100 f */
0x04, /* 0x00000100 f */
0x00, /* 0x00000000 f */
0x00, /* 0x00000000 f */
0x00, /* 0x00000000 f */
/* */
0x00, /* 0x00000000 g */
0x00, /* 0x00000000 g */
0x00, /* 0x00000000 g */
0x00, /* 0x00000000 g */
0x00, /* 0x00000000 g */
0x5e, /* 0x01011110 g */
0x21, /* 0x00100001 g */
0x21, /* 0x00100001 g */
0x21, /* 0x00100001 g */
0x1e, /* 0x00011110 g */
0x01, /* 0x00000001 g */
0x3e, /* 0x00111110 g */
0x41, /* 0x01000001 g */
0x41, /* 0x01000001 g */
0x3e, /* 0x00111110 g */
/* */
0x00, /* 0x00000000 h */
0x00, /* 0x00000000 h */
0x01, /* 0x00000001 h */
0x01, /* 0x00000001 h */
0x01, /* 0x00000001 h */
0x3d, /* 0x00111101 h */
0x43, /* 0x01000011 h */
0x41, /* 0x01000001 h */
0x41, /* 0x01000001 h */
0x41, /* 0x01000001 h */
0x41, /* 0x01000001 h */
0x41, /* 0x01000001 h */
0x00, /* 0x00000000 h */
0x00, /* 0x00000000 h */
0x00, /* 0x00000000 h */
/* */
0x00, /* 0x00000000 i */
0x00, /* 0x00000000 i */
0x00, /* 0x00000000 i */
0x08, /* 0x00001000 i */
0x00, /* 0x00000000 i */
0x0c, /* 0x00001100 i */
0x08, /* 0x00001000 i */
0x08, /* 0x00001000 i */
0x08, /* 0x00001000 i */
0x08, /* 0x00001000 i */
0x08, /* 0x00001000 i */
0x3e, /* 0x00111110 i */
0x00, /* 0x00000000 i */
0x00, /* 0x00000000 i */
0x00, /* 0x00000000 i */
/* */
0x00, /* 0x00000000 j */
0x00, /* 0x00000000 j */
0x00, /* 0x00000000 j */
0x20, /* 0x00100000 j */
0x00, /* 0x00000000 j */
0x38, /* 0x00111000 j */
0x20, /* 0x00100000 j */
0x20, /* 0x00100000 j */
0x20, /* 0x00100000 j */
0x20, /* 0x00100000 j */
0x20, /* 0x00100000 j */
0x21, /* 0x00100001 j */
0x21, /* 0x00100001 j */
0x21, /* 0x00100001 j */
0x1e, /* 0x00011110 j */
/* */
0x00, /* 0x00000000 k */
0x00, /* 0x00000000 k */
0x01, /* 0x00000001 k */
0x01, /* 0x00000001 k */
0x01, /* 0x00000001 k */
0x41, /* 0x01000001 k */
0x31, /* 0x00110001 k */
0x0d, /* 0x00001101 k */
0x03, /* 0x00000011 k */
0x0d, /* 0x00001101 k */
0x31, /* 0x00110001 k */
0x41, /* 0x01000001 k */
0x00, /* 0x00000000 k */
0x00, /* 0x00000000 k */
0x00, /* 0x00000000 k */
/* */
0x00, /* 0x00000000 l */
0x00, /* 0x00000000 l */
0x0c, /* 0x00001100 l */
0x08, /* 0x00001000 l */
0x08, /* 0x00001000 l */
0x08, /* 0x00001000 l */
0x08, /* 0x00001000 l */
0x08, /* 0x00001000 l */
0x08, /* 0x00001000 l */
0x08, /* 0x00001000 l */
0x08, /* 0x00001000 l */
0x3e, /* 0x00111110 l */
0x00, /* 0x00000000 l */
0x00, /* 0x00000000 l */
0x00, /* 0x00000000 l */
/* */
0x00, /* 0x00000000 m */
0x00, /* 0x00000000 m */
0x00, /* 0x00000000 m */
0x00, /* 0x00000000 m */
0x00, /* 0x00000000 m */
0x37, /* 0x00110111 m */
0x49, /* 0x01001001 m */
0x49, /* 0x01001001 m */
0x49, /* 0x01001001 m */
0x49, /* 0x01001001 m */
0x49, /* 0x01001001 m */
0x41, /* 0x01000001 m */
0x00, /* 0x00000000 m */
0x00, /* 0x00000000 m */
0x00, /* 0x00000000 m */
/* */
0x00, /* 0x00000000 n */
0x00, /* 0x00000000 n */
0x00, /* 0x00000000 n */
0x00, /* 0x00000000 n */
0x00, /* 0x00000000 n */
0x3d, /* 0x00111101 n */
0x43, /* 0x01000011 n */
0x41, /* 0x01000001 n */
0x41, /* 0x01000001 n */
0x41, /* 0x01000001 n */
0x41, /* 0x01000001 n */
0x41, /* 0x01000001 n */
0x00, /* 0x00000000 n */
0x00, /* 0x00000000 n */
0x00, /* 0x00000000 n */
/* */
0x00, /* 0x00000000 o */
0x00, /* 0x00000000 o */
0x00, /* 0x00000000 o */
0x00, /* 0x00000000 o */
0x00, /* 0x00000000 o */
0x3e, /* 0x00111110 o */
0x41, /* 0x01000001 o */
0x41, /* 0x01000001 o */
0x41, /* 0x01000001 o */
0x41, /* 0x01000001 o */
0x41, /* 0x01000001 o */
0x3e, /* 0x00111110 o */
0x00, /* 0x00000000 o */
0x00, /* 0x00000000 o */
0x00, /* 0x00000000 o */
/* */
0x00, /* 0x00000000 p */
0x00, /* 0x00000000 p */
0x00, /* 0x00000000 p */
0x00, /* 0x00000000 p */
0x00, /* 0x00000000 p */
0x3d, /* 0x00111101 p */
0x43, /* 0x01000011 p */
0x41, /* 0x01000001 p */
0x41, /* 0x01000001 p */
0x41, /* 0x01000001 p */
0x43, /* 0x01000011 p */
0x3d, /* 0x00111101 p */
0x01, /* 0x00000001 p */
0x01, /* 0x00000001 p */
0x01, /* 0x00000001 p */
/* */
0x00, /* 0x00000000 q */
0x00, /* 0x00000000 q */
0x00, /* 0x00000000 q */
0x00, /* 0x00000000 q */
0x00, /* 0x00000000 q */
0x5e, /* 0x01011110 q */
0x61, /* 0x01100001 q */
0x41, /* 0x01000001 q */
0x41, /* 0x01000001 q */
0x41, /* 0x01000001 q */
0x61, /* 0x01100001 q */
0x5e, /* 0x01011110 q */
0x40, /* 0x01000000 q */
0x40, /* 0x01000000 q */
0x40, /* 0x01000000 q */
/* */
0x00, /* 0x00000000 r */
0x00, /* 0x00000000 r */
0x00, /* 0x00000000 r */
0x00, /* 0x00000000 r */
0x00, /* 0x00000000 r */
0x39, /* 0x00111001 r */
0x46, /* 0x01000110 r */
0x42, /* 0x01000010 r */
0x02, /* 0x00000010 r */
0x02, /* 0x00000010 r */
0x02, /* 0x00000010 r */
0x02, /* 0x00000010 r */
0x00, /* 0x00000000 r */
0x00, /* 0x00000000 r */
0x00, /* 0x00000000 r */
/* */
0x00, /* 0x00000000 s */
0x00, /* 0x00000000 s */
0x00, /* 0x00000000 s */
0x00, /* 0x00000000 s */
0x00, /* 0x00000000 s */
0x3e, /* 0x00111110 s */
0x41, /* 0x01000001 s */
0x01, /* 0x00000001 s */
0x3e, /* 0x00111110 s */
0x40, /* 0x01000000 s */
0x41, /* 0x01000001 s */
0x3e, /* 0x00111110 s */
0x00, /* 0x00000000 s */
0x00, /* 0x00000000 s */
0x00, /* 0x00000000 s */
/* */
0x00, /* 0x00000000 t */
0x00, /* 0x00000000 t */
0x00, /* 0x00000000 t */
0x04, /* 0x00000100 t */
0x04, /* 0x00000100 t */
0x3f, /* 0x00111111 t */
0x04, /* 0x00000100 t */
0x04, /* 0x00000100 t */
0x04, /* 0x00000100 t */
0x04, /* 0x00000100 t */
0x44, /* 0x01000100 t */
0x38, /* 0x00111000 t */
0x00, /* 0x00000000 t */
0x00, /* 0x00000000 t */
0x00, /* 0x00000000 t */
/* */
0x00, /* 0x00000000 u */
0x00, /* 0x00000000 u */
0x00, /* 0x00000000 u */
0x00, /* 0x00000000 u */
0x00, /* 0x00000000 u */
0x21, /* 0x00100001 u */
0x21, /* 0x00100001 u */
0x21, /* 0x00100001 u */
0x21, /* 0x00100001 u */
0x21, /* 0x00100001 u */
0x21, /* 0x00100001 u */
0x5e, /* 0x01011110 u */
0x00, /* 0x00000000 u */
0x00, /* 0x00000000 u */
0x00, /* 0x00000000 u */
/* */
0x00, /* 0x00000000 v */
0x00, /* 0x00000000 v */
0x00, /* 0x00000000 v */
0x00, /* 0x00000000 v */
0x00, /* 0x00000000 v */
0x41, /* 0x01000001 v */
0x41, /* 0x01000001 v */
0x22, /* 0x00100010 v */
0x22, /* 0x00100010 v */
0x14, /* 0x00010100 v */
0x14, /* 0x00010100 v */
0x08, /* 0x00001000 v */
0x00, /* 0x00000000 v */
0x00, /* 0x00000000 v */
0x00, /* 0x00000000 v */
/* */
0x00, /* 0x00000000 w */
0x00, /* 0x00000000 w */
0x00, /* 0x00000000 w */
0x00, /* 0x00000000 w */
0x00, /* 0x00000000 w */
0x41, /* 0x01000001 w */
0x41, /* 0x01000001 w */
0x49, /* 0x01001001 w */
0x49, /* 0x01001001 w */
0x49, /* 0x01001001 w */
0x55, /* 0x01010101 w */
0x22, /* 0x00100010 w */
0x00, /* 0x00000000 w */
0x00, /* 0x00000000 w */
0x00, /* 0x00000000 w */
/* */
0x00, /* 0x00000000 x */
0x00, /* 0x00000000 x */
0x00, /* 0x00000000 x */
0x00, /* 0x00000000 x */
0x00, /* 0x00000000 x */
0x41, /* 0x01000001 x */
0x22, /* 0x00100010 x */
0x14, /* 0x00010100 x */
0x08, /* 0x00001000 x */
0x14, /* 0x00010100 x */
0x22, /* 0x00100010 x */
0x41, /* 0x01000001 x */
0x00, /* 0x00000000 x */
0x00, /* 0x00000000 x */
0x00, /* 0x00000000 x */
/* */
0x00, /* 0x00000000 y */
0x00, /* 0x00000000 y */
0x00, /* 0x00000000 y */
0x00, /* 0x00000000 y */
0x00, /* 0x00000000 y */
0x21, /* 0x00100001 y */
0x21, /* 0x00100001 y */
0x21, /* 0x00100001 y */
0x21, /* 0x00100001 y */
0x21, /* 0x00100001 y */
0x31, /* 0x00110001 y */
0x2e, /* 0x00101110 y */
0x20, /* 0x00100000 y */
0x21, /* 0x00100001 y */
0x1e, /* 0x00011110 y */
/* */
0x00, /* 0x00000000 z */
0x00, /* 0x00000000 z */
0x00, /* 0x00000000 z */
0x00, /* 0x00000000 z */
0x00, /* 0x00000000 z */
0x7f, /* 0x01111111 z */
0x20, /* 0x00100000 z */
0x10, /* 0x00010000 z */
0x08, /* 0x00001000 z */
0x04, /* 0x00000100 z */
0x02, /* 0x00000010 z */
0x7f, /* 0x01111111 z */
0x00, /* 0x00000000 z */
0x00, /* 0x00000000 z */
0x00, /* 0x00000000 z */
/* */
0x00, /* 0x00000000 { */
0x00, /* 0x00000000 { */
0x70, /* 0x01110000 { */
0x08, /* 0x00001000 { */
0x08, /* 0x00001000 { */
0x10, /* 0x00010000 { */
0x0c, /* 0x00001100 { */
0x0c, /* 0x00001100 { */
0x10, /* 0x00010000 { */
0x08, /* 0x00001000 { */
0x08, /* 0x00001000 { */
0x70, /* 0x01110000 { */
0x00, /* 0x00000000 { */
0x00, /* 0x00000000 { */
0x00, /* 0x00000000 { */
/* */
0x00, /* 0x00000000 | */
0x00, /* 0x00000000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x08, /* 0x00001000 | */
0x00, /* 0x00000000 | */
0x00, /* 0x00000000 | */
0x00, /* 0x00000000 | */
/* */
0x00, /* 0x00000000 } */
0x00, /* 0x00000000 } */
0x07, /* 0x00000111 } */
0x08, /* 0x00001000 } */
0x08, /* 0x00001000 } */
0x04, /* 0x00000100 } */
0x18, /* 0x00011000 } */
0x18, /* 0x00011000 } */
0x04, /* 0x00000100 } */
0x08, /* 0x00001000 } */
0x08, /* 0x00001000 } */
0x07, /* 0x00000111 } */
0x00, /* 0x00000000 } */
0x00, /* 0x00000000 } */
0x00, /* 0x00000000 } */
/* */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x46, /* 0x01000110 ~ */
0x49, /* 0x01001001 ~ */
0x31, /* 0x00110001 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
0x00, /* 0x00000000 ~ */
/* */
/* ascii0241 */
0x00,
0x00,
0x00,
0x10,
0x00,
0x10,
0x10,
0x10,
0x10,
0x10,
0x10,
0x10,
0x10,
0x00,
0x00,
/* ascii0242 */
0x00,
0x00,
0x00,
0x00,
0x10,
0x10,
0x3c,
0x42,
0x02,
0x02,
0x42,
0x3c,
0x10,
0x10,
0x00,
/* ascii0243 */
0x00,
0x00,
0x70,
0x88,
0x08,
0x08,
0x08,
0x3e,
0x08,
0x08,
0x08,
0xdc,
0x76,
0x00,
0x00,
/* ascii0244 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0245 */
0x00,
0x00,
0x00,
0x44,
0x44,
0x44,
0x28,
0x10,
0x7c,
0x10,
0x7c,
0x10,
0x10,
0x00,
0x00,
/* ascii0246 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0247 */
0x00,
0x1c,
0x22,
0x02,
0x04,
0x1c,
0x22,
0x22,
0x1c,
0x10,
0x20,
0x22,
0x1c,
0x00,
0x00,
/* ascii0250 */
0x00,
0x00,
0x00,
0x00,
0x82,
0x44,
0x38,
0x44,
0x44,
0x44,
0x38,
0x44,
0x82,
0x00,
0x00,
/* ascii0251 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x7c,
0x82,
0xb2,
0x8a,
0x8a,
0xb2,
0x82,
0x7c,
0x00,
0x00,
/* ascii0252 */
0x00,
0x00,
0x00,
0x3c,
0x40,
0x7c,
0x42,
0x42,
0x7c,
0x00,
0x7c,
0x00,
0x00,
0x00,
0x00,
/* ascii0253 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x48,
0x24,
0x12,
0x09,
0x12,
0x24,
0x48,
0x00,
0x00,
0x00,
/* ascii0254 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0255 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0256 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0257 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0260 */
0x00,
0x18,
0x24,
0x24,
0x18,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
/* ascii0261 */
0x00,
0x00,
0x00,
0x08,
0x08,
0x08,
0x3e,
0x08,
0x08,
0x08,
0x00,
0x3e,
0x00,
0x00,
0x00,
/* ascii0262 */
0x00,
0x00,
0x0c,
0x12,
0x08,
0x04,
0x02,
0x1e,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
/* ascii0263 */
0x00,
0x00,
0x1e,
0x10,
0x08,
0x10,
0x12,
0x0c,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
/* ascii0264 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0265 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x44,
0x44,
0x44,
0x44,
0x44,
0x7c,
0xc2,
0x01,
/* ascii0266 */
0x00,
0x00,
0x00,
0x7c,
0x4e,
0x4e,
0x4e,
0x4e,
0x7c,
0x48,
0x48,
0x48,
0x48,
0x00,
0x00,
/* ascii0267 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x18,
0x18,
0x00,
0x00,
0x00,
0x00,
0x00,
/* ascii0270 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0271 */
0x00,
0x00,
0x08,
0x0c,
0x08,
0x08,
0x08,
0x1c,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
/* ascii0272 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x3c,
0x00,
0x00,
0x00,
0x00,
/* ascii0273 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x12,
0x24,
0x48,
0x90,
0x48,
0x24,
0x12,
0x00,
0x00,
/* ascii0274 */
0x00,
0x04,
0x06,
0x04,
0x04,
0x4e,
0x20,
0x10,
0x48,
0x64,
0x52,
0xf8,
0x40,
0x40,
0x00,
/* ascii0275 */
0x00,
0x04,
0x06,
0x04,
0x04,
0x4e,
0x20,
0x10,
0x08,
0x74,
0x82,
0x60,
0x10,
0xf0,
0x00,
/* ascii0276 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0277 */
0x00,
0x00,
0x00,
0x10,
0x00,
0x10,
0x10,
0x08,
0x04,
0x02,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0300 */
0x00,
0x08,
0x10,
0x20,
0x18,
0x24,
0x42,
0x42,
0x42,
0x7e,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0301 */
0x00,
0x10,
0x08,
0x04,
0x18,
0x24,
0x42,
0x42,
0x42,
0x7e,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0302 */
0x00,
0x18,
0x24,
0x42,
0x18,
0x24,
0x42,
0x42,
0x42,
0x7e,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0303 */
0x00,
0x4c,
0x32,
0x00,
0x18,
0x24,
0x42,
0x42,
0x42,
0x7e,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0304 */
0x00,
0x00,
0x66,
0x00,
0x18,
0x24,
0x42,
0x42,
0x42,
0x7e,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0305 */
0x18,
0x24,
0x18,
0x00,
0x18,
0x24,
0x42,
0x42,
0x42,
0x7e,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0306 */
0x00,
0x00,
0x00,
0x00,
0xf8,
0x14,
0x12,
0x12,
0x7e,
0x12,
0x12,
0x12,
0xf2,
0x00,
0x00,
/* ascii0307 */
0x00,
0x00,
0x00,
0x00,
0x3c,
0x42,
0x02,
0x02,
0x02,
0x02,
0x02,
0x42,
0x3c,
0x10,
0x0c,
/* ascii0310 */
0x08,
0x10,
0x20,
0x00,
0x7e,
0x02,
0x02,
0x02,
0x1e,
0x02,
0x02,
0x02,
0x7e,
0x00,
0x00,
/* ascii0311 */
0x10,
0x08,
0x04,
0x00,
0x7e,
0x02,
0x02,
0x02,
0x1e,
0x02,
0x02,
0x02,
0x7e,
0x00,
0x00,
/* ascii0312 */
0x18,
0x24,
0x42,
0x00,
0x7e,
0x02,
0x02,
0x02,
0x1e,
0x02,
0x02,
0x02,
0x7e,
0x00,
0x00,
/* ascii0313 */
0x00,
0x66,
0x00,
0x00,
0x7e,
0x02,
0x02,
0x02,
0x1e,
0x02,
0x02,
0x02,
0x7e,
0x00,
0x00,
/* ascii0314 */
0x08,
0x10,
0x20,
0x00,
0x3c,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0315 */
0x40,
0x20,
0x10,
0x00,
0x3c,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0316 */
0x18,
0x24,
0x42,
0x00,
0x3c,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0317 */
0x00,
0x66,
0x00,
0x00,
0x3c,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0320 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0321 */
0x00,
0x4c,
0x32,
0x00,
0x42,
0x42,
0x46,
0x4a,
0x52,
0x62,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0322 */
0x08,
0x10,
0x20,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0323 */
0x10,
0x08,
0x04,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0324 */
0x18,
0x24,
0x42,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0325 */
0x00,
0x4c,
0x32,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0326 */
0x00,
0x66,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0327 */
0x00,
0x00,
0x00,
0x00,
0xfc,
0x12,
0x12,
0x12,
0x72,
0x12,
0x12,
0x12,
0xfc,
0x00,
0x00,
/* ascii0330 */
0x00,
0x00,
0x00,
0x00,
0xbc,
0x42,
0x62,
0x52,
0x52,
0x4a,
0x46,
0x42,
0x3d,
0x00,
0x00,
/* ascii0331 */
0x00,
0x04,
0x08,
0x10,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0332 */
0x00,
0x20,
0x10,
0x08,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0333 */
0x00,
0x18,
0x24,
0x42,
0x00,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0334 */
0x00,
0x66,
0x00,
0x00,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0335 */
0x00,
0xc6,
0x00,
0x00,
0x82,
0x82,
0x44,
0x28,
0x10,
0x10,
0x10,
0x10,
0x10,
0x00,
0x00,
/* ascii0336 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0337 */
0x00,
0x00,
0x70,
0x88,
0x84,
0x84,
0x44,
0x74,
0x84,
0x84,
0x84,
0x94,
0x74,
0x04,
0x02,
/* ascii0340 */
0x00,
0x00,
0x00,
0x08,
0x10,
0x20,
0x00,
0x3c,
0x40,
0x7c,
0x42,
0x42,
0x7c,
0x00,
0x00,
/* ascii0341 */
0x00,
0x00,
0x00,
0x10,
0x08,
0x04,
0x00,
0x3c,
0x40,
0x7c,
0x42,
0x42,
0x7c,
0x00,
0x00,
/* ascii0342 */
0x00,
0x00,
0x00,
0x18,
0x24,
0x42,
0x00,
0x3c,
0x40,
0x7c,
0x42,
0x42,
0x7c,
0x00,
0x00,
/* ascii0343 */
0x00,
0x00,
0x00,
0x00,
0x4c,
0x32,
0x00,
0x3c,
0x40,
0x7c,
0x42,
0x42,
0x7c,
0x00,
0x00,
/* ascii0344 */
0x00,
0x00,
0x00,
0x00,
0x66,
0x00,
0x00,
0x3c,
0x40,
0x7c,
0x42,
0x42,
0x7c,
0x00,
0x00,
/* ascii0345 */
0x00,
0x00,
0x00,
0x18,
0x24,
0x18,
0x00,
0x3c,
0x40,
0x7c,
0x42,
0x42,
0x7c,
0x00,
0x00,
/* ascii0346 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x6e,
0x90,
0xfc,
0x12,
0x12,
0xec,
0x00,
0x00,
/* ascii0347 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x3c,
0x42,
0x02,
0x02,
0x42,
0x3c,
0x10,
0x0c,
/* ascii0350 */
0x00,
0x00,
0x00,
0x08,
0x10,
0x20,
0x00,
0x3c,
0x42,
0x7e,
0x02,
0x02,
0x3c,
0x00,
0x00,
/* ascii0351 */
0x00,
0x00,
0x00,
0x10,
0x08,
0x04,
0x00,
0x3c,
0x42,
0x7e,
0x02,
0x02,
0x3c,
0x00,
0x00,
/* ascii0352 */
0x00,
0x00,
0x00,
0x18,
0x24,
0x42,
0x00,
0x3c,
0x42,
0x7e,
0x02,
0x02,
0x3c,
0x00,
0x00,
/* ascii0353 */
0x00,
0x00,
0x00,
0x00,
0x66,
0x00,
0x00,
0x3c,
0x42,
0x7e,
0x02,
0x02,
0x3c,
0x00,
0x00,
/* ascii0354 */
0x00,
0x00,
0x00,
0x04,
0x08,
0x10,
0x00,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0355 */
0x00,
0x00,
0x00,
0x10,
0x08,
0x04,
0x00,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0356 */
0x00,
0x00,
0x00,
0x18,
0x24,
0x42,
0x00,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0357 */
0x00,
0x00,
0x00,
0x00,
0x66,
0x00,
0x00,
0x08,
0x08,
0x08,
0x08,
0x08,
0x3c,
0x00,
0x00,
/* ascii0360 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0361 */
0x00,
0x00,
0x00,
0x4c,
0x32,
0x00,
0x00,
0x3e,
0x42,
0x42,
0x42,
0x42,
0x42,
0x00,
0x00,
/* ascii0362 */
0x00,
0x00,
0x00,
0x08,
0x10,
0x20,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0363 */
0x00,
0x00,
0x00,
0x10,
0x08,
0x04,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0364 */
0x00,
0x00,
0x00,
0x18,
0x24,
0x42,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0365 */
0x00,
0x00,
0x00,
0x4c,
0x32,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0366 */
0x00,
0x00,
0x00,
0x00,
0x66,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0367 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x6c,
0x92,
0xf2,
0x12,
0x12,
0xec,
0x00,
0x00,
/* ascii0370 */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xbc,
0x62,
0x52,
0x4a,
0x46,
0x3c,
0x02,
0x00,
/* ascii0371 */
0x00,
0x00,
0x00,
0x04,
0x08,
0x10,
0x00,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0372 */
0x00,
0x00,
0x00,
0x20,
0x10,
0x08,
0x00,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0373 */
0x00,
0x00,
0x00,
0x18,
0x24,
0x42,
0x00,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0374 */
0x00,
0x00,
0x00,
0x00,
0x66,
0x00,
0x00,
0x42,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x00,
0x00,
/* ascii0375 */
0x00,
0x00,
0x00,
0x00,
0x66,
0x00,
0x00,
0x42,
0x42,
0x42,
0x42,
0x3c,
0x40,
0x40,
0x3e,
/* ascii0376 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
/* ascii0377 */
0x00,
0x00,
0x00,
0x3c,
0x42,
0x42,
0x02,
0x04,
0x08,
0x10,
0x10,
0x00,
0x10,
0x00,
0x00,
};
/*
* Default Cursor
*/
unsigned short q_cursor[] = {
0x0000,
0x0000,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x00ff,
0x0000,
0x0000,
0x0000
};
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.