void solve() {
int64 argument;
{
FILE *in = fopen("function.in" ,"r");
fscanf(in,"%lld",&argument);
fclose(in );
}
cache = (int32*)malloc(sizeof(int32*)*(argument+1));
memset(cache,0,argument+1);
{
//todo: realloc
request **stack = (request**)malloc(sizeof(request*)*INIT_STACK);
( *stack) = (request* )malloc(sizeof(request ));
(**stack) = create_request(argument);
request **bottom = stack;
do {
request current = **bottom;
int64 value = current.argument;
if (value < 3 || cache[value] != 0) {
incCounter(value);
free(*bottom);
bottom--;
} else {
int64 left, right;
if (value % 2 == 0) {
left = value - 1;
right = value - 3;
} else {
left = (value / 7)*6 + ((value % 7)*6)/7;
right = (value / 3)*2 + ((value % 3)*2)/3;
}
if (cache[left] == 0 || cache[right] == 0) {
//left and right will be computed twice =/
processArg(left, &bottom);
processArg(right,&bottom);
} else {
cache[value] = (cache[left] + cache[right]) % two32;
}
}
} while (bottom != stack);
}
{
FILE *out = fopen("function.out","w");
fprintf(out,"%lld",counter);
fclose(out);
}
}
void FMUCodeGen::genModelVariables(FMI::ModelVariables &mvars)
{
set<SFC::Program> programs = _sfprj.Program_kind_children();
for(set<SFC::Program>::iterator it=programs.begin();it!=programs.end();++it)
{
set<SFC::Class> clss = (*it).Class_kind_children();
for(set<SFC::Class>::iterator clss_it=clss.begin();clss_it!=clss.end();++clss_it)
{
set<SFC::Function> funcs = (*clss_it).Function_kind_children();
for(set<SFC::Function>::iterator funcs_it=funcs.begin();funcs_it!=funcs.end();++funcs_it)
{
SFC::Function func = *funcs_it;
set<SFC::FunctionCall> func_calls = func.caller();
if(func_calls.empty())
{
set<SFC::Arg, ArgIndexPredicate> args = func.Arg_kind_children_sorted(ArgIndexPredicate());
for(set<SFC::Arg, ArgIndexPredicate>::iterator args_it=args.begin();args_it!=args.end();++args_it)
{
const SFC::Arg &arg = *args_it;
if((std::string)arg.type()!="")
processArg(mvars, arg);
}
}
}
}
}
}
/*
* -----------------------------------------------------------------------------
* Main
* -----------------------------------------------------------------------------
*/
int32_t main(int32_t aArgc, char *aArgv[])
{
perfContext sContext;
struct timeval sStart, sEnd;
int32_t sSeconds, sUseconds;
uint32_t *sArray;
/*
* Init
*/
perfContextInit(&sContext);
processArg(aArgc, aArgv, &sContext);
/*
* Allocate memory and load data
*/
(void)fprintf(stderr, "Reading data...\n");
createAndFillArray(&sContext);
sArray = sContext.mArrayToSort;
/*
* Sort it!
*/
(void)fprintf(stderr, "Start sorting...\n");
(void)gettimeofday(&sStart, NULL);
(*sContext.mSortFunc)(sArray, sContext.mCount, sizeof(uint32_t), compareFunc);
(void)gettimeofday(&sEnd, NULL);
(void)fprintf(stderr, "Completed sorting.\n");
/*
* Calculate time
*/
sSeconds = sEnd.tv_sec - sStart.tv_sec;
sUseconds = sEnd.tv_usec - sStart.tv_usec;
if (sUseconds < 0)
{
sSeconds--;
sUseconds += 1000000;
}
(void)fprintf(stderr, "\nIt took %d.%06d seconds to sort %d elements.\n\n",
sSeconds, sUseconds, sContext.mCount);
/*
* Verify if option is set
*/
if (sContext.mDoVerify == 1)
{
(void)fprintf(stderr, "Checking if resulting array is correctly sorted...... ");
if (verifyArrayIsSorted(sArray, sContext.mCount) == 0)
{
(void)fprintf(stderr, "OK\n");
}
else
{
(void)fprintf(stderr, "FAIL\n");
}
}
/*
* Free memory
*/
destroyArray(sArray);
return 0;
}
configuration_t *clparser(int argc, char ** argv) {
configuration_t *conf;
char *aOpt[] = {"aes128", "aes192", "aes256", "des"};
char *mOpt[] = {"ecb", "cfb", "ofb", "cbc"};
char *stegOpt[] = {"LSB1", "LSB4", "LSBE", "WANTED"};
if((conf = calloc(sizeof(configuration_t),1)) == NULL){
return NULL;
}
parserADT parser = newParser(argc, argv);
setArg(parser, arg_in, "-in", 0, 1, ARG_TYPE1, 0, NULL);
setArg(parser, arg_out, "-out", 0, 1, ARG_TYPE1, 0, NULL);
setArg(parser, arg_porter, "-p", 0, 1, ARG_TYPE1, 0, NULL);
setArg(parser, arg_embed, "-embed", 1, 1, ARG_TYPE0, 0, NULL);
setArg(parser, arg_extract, "-extract", 1, 1, ARG_TYPE0, 0, NULL);
setArg(parser, arg_pass, "-pass", 1, 1, ARG_TYPE1, 0, NULL);
setArg(parser, arg_algorithm, "-a", 1, 1, ARG_TYPE1, SIZE_OF_ARRAY(aOpt), aOpt);
setArg(parser, arg_ciphermode, "-m", 1, 1, ARG_TYPE1, SIZE_OF_ARRAY(mOpt) , mOpt);
setArg(parser, arg_steg, "-steg", 1, 1, ARG_TYPE1, SIZE_OF_ARRAY(stegOpt), stegOpt);
setArg(parser, arg_help, "-h", 1, 1, ARG_TYPE0, 0, NULL); //help
int error = 0;
while(!noMoreArgs(parser) && !error){
switch(getArg(parser)){
case arg_out:
error = !processArg(&conf->targetFile, getValue(parser), "target file");
break;
case arg_in:
error = !processArg(&conf->sourceFile, getValue(parser), "source file");
break;
case arg_porter:
error = !processArg(&conf->carrierFile, getValue(parser), "carrier file");
break;
case arg_embed:
if(conf->embed == steg_notSet){
LOG("embed/extract is embed\n");
conf->embed = steg_embed;
if(conf->encriptation != NULL) {
conf->encriptation->encrypOrDecrypt = encrypOrDecrypt_encrypt;
}
}
else {
printf("embed/extract already set\n");
error = 1;
}
break;
case arg_extract:
if(conf->embed == steg_notSet){
LOG("embed/extract is extract\n");
conf->embed = steg_extract;
if(conf->encriptation != NULL) {
conf->encriptation->encrypOrDecrypt = encrypOrDecrypt_decrypt;
}
} else {
printf("embed/extract already set\n");
error = 1;
}
break;
case arg_pass:
if(!initEncrypt(conf)){
error = 1;
} else {
error = !processArg((char**)&conf->encriptation->passKeyIv.password, getValue(parser), "password");
}
break;
case arg_algorithm:
if(!initEncrypt(conf)){
error = 1;
} else {
algorithm_t alg = getCryptoAlgorithm(getValue(parser));
if(alg != algorithm_none){
setCryptoAlgorithm(conf->encriptation, alg);
} else {
printf("encryptation algorithm not reconized: %s\n", getValue(parser));
error = 1;
}
}
break;
case arg_ciphermode:
if(!initEncrypt(conf)){
error = 1;
} else {
ciphermode_t cipherm = getCipherMode(getValue(parser));
if(cipherm != ciphermode_none){
setCryptoCiphermode(conf->encriptation, cipherm);
} else {
printf("ciphermode not reconized: %s\n", getValue(parser));
error = 1;
}
}
break;
case arg_steg:
if(conf->stegMode != stegMode_none){
printf("steg already set\n");
error = 1;
} else {
stegMode_t mode = getStegMode(getValue(parser));
if(mode == stegMode_none){
printf("steg mode not reconized: %s\n", getValue(parser));
error = 1;
} else {
conf->stegMode = mode;
}
}
break;
case arg_help:
showHelp();
return NULL;
break;
default:
error = 1;
break;
}
}
return conf;
}
int loggerJavacParserCollectActions(
const char* prog_,
const char* toolName_,
const char* const argv_[],
LoggerVector* actions_)
{
ParserData data;
size_t i;
assert(prog_ == prog_); /* suppress unused variable */
data.hasSourcePath = 0;
data.state = Normal;
loggerVectorInit(&data.commonArgs);
loggerVectorInit(&data.sources);
memset(data.classdir, 0, sizeof(data.classdir));
loggerVectorAdd(&data.commonArgs, loggerStrDup(toolName_));
for (i = 1; argv_[i]; ++i)
{
if (argv_[i][0] == '@')
{
size_t j;
LoggerVector fargs;
loggerVectorInit(&fargs);
readArgumentsFromFile(argv_[i] + 1, &fargs);
for (j = 0; j < fargs.size; ++j)
{
processArg((const char*) fargs.data[j], &data);
}
loggerVectorClear(&fargs);
}
else
{
processArg(argv_[i], &data);
}
}
if (!data.hasSourcePath)
{
char workdir[PATH_MAX];
if (loggerMakePathAbs(".", workdir, 0))
{
loggerVectorAdd(&data.commonArgs, loggerStrDup("-sourcepath"));
loggerVectorAdd(&data.commonArgs, loggerStrDup(workdir));
}
}
for (i = 0; i < data.sources.size; ++i)
{
char outputFile[PATH_MAX];
const char* src = (char*) data.sources.data[i];
LoggerAction* action = loggerActionNew(toolName_);
if (!action)
{
continue;
}
loggerVectorAddFrom(&action->arguments, &data.commonArgs,
NULL, (LoggerDupFuc) &loggerStrDup);
loggerVectorAdd(&action->arguments, loggerStrDup(src));
loggerVectorAdd(&action->sources, loggerStrDup(src));
if (data.classdir[0] != 0)
{
char* fname = loggerGetFileName(src, 1);
strcpy(outputFile, data.classdir);
strcat(outputFile, "/");
strcat(outputFile, fname);
strcat(outputFile, ".class");
free(fname);
}
else
{
char* path = loggerGetFilePathWithoutExt(src);
strcpy(outputFile, path);
strcat(outputFile, ".class");
free(path);
}
loggerFileInitFromPath(&action->output, outputFile);
loggerVectorAdd(actions_, action);
}
loggerVectorClear(&data.commonArgs);
loggerVectorClear(&data.sources);
return 1;
}
