/*
* print_flag_set
* Prints a set of flags which are set in an integer. The names and values of
* the possible flags are taken from an array passed as the fourth argument.
* All flags in the array are expected to be distinct, and non-zero.
*/
static char *
print_flag_set(char *buffer_start, char *c, long flags,
const struct flag_desc *desc)
{
bool is_zero = flags == 0;
while (flags != 0 && desc->printable_name != NULL) {
if (is_zero && desc->flag == 0)
return print_flag(buffer_start, c,
desc->printable_name);
if ((flags & desc->flag) != 0) {
c = print_flag(buffer_start, c, desc->printable_name);
flags &= ~desc->flag;
}
desc++;
}
if (flags != 0) {
if (c != buffer_start)
c = print_cstr(c, " | ");
c = print_hex(c, flags);
}
if (c == buffer_start)
c = print_cstr(c, "0");
return c;
}
static void print_ptable(offset_manager_t *mngr) {
offset_poly_table_t *table;
uint32_t i, n;
table = &mngr->ptable;
printf("===== ptable ====\n");
n = table->npolys;
for (i=0; i<n; i++) {
printf("poly[%"PRIu32"] := ", i);
show_poly(table->def[i]);
printf(" (eterm: t!%"PRId32, table->eterm[i]);
printf(", active: ");
print_flag(tst_bit(table->active, i));
printf(", mark: ");
print_flag(tst_bit(table->mark, i));
printf(")\n");
printf(" normal form: ");
print_normal_form(&mngr->vtable, table->def[i]);
printf("\n");
printf(" vars: ");
print_var_array(table->vars[i]);
printf("\n");
}
printf("\n");
}
const char* buildflagset_print(buildflagset_t* set)
{
assert(set != NULL);
assert(set->flags != NULL);
char* p = set->text_buffer;
// First the mutually exclusive flags.
if(set->have_os_flags)
print_flag(_os_flags[set->enum_os_flags], true, set, &p);
if(set->have_arch_flags)
print_flag(_arch_flags[set->enum_arch_flags], true, set, &p);
if(set->have_size_flags)
print_flag(_size_flags[set->enum_size_flags], true, set, &p);
// Next the normal flags, in any order.
size_t i = HASHMAP_BEGIN;
flag_t* flag;
while((flag = flagtab_next(set->flags, &i)) != NULL)
print_flag(flag->name, flag->value, set, &p);
if(p == set->text_buffer) // No flags, all configs match.
print_str("all configs", set, &p);
// Check buffer was big enough for it all.
size_t size_needed = (p - set->text_buffer) + 1; // +1 for terminator.
if(size_needed > set->buffer_size)
{
// Buffer we have isn't big enough, make it bigger then go round again.
if(set->buffer_size > 0)
ponyint_pool_free_size(set->buffer_size, set->text_buffer);
set->text_buffer = (char*)ponyint_pool_alloc_size(size_needed);
set->buffer_size = size_needed;
set->text_buffer[0] = '\0';
buildflagset_print(set);
}
// Add terminator.
assert(set->text_buffer != NULL);
set->text_buffer[size_needed - 1] = '\0';
return set->text_buffer;
}
static fssh_status_t
command_info(int argc, const char* const* argv)
{
fssh_dev_t volumeID = get_volume_id();
if (volumeID < 0)
return volumeID;
fssh_fs_info info;
fssh_status_t status = _kern_read_fs_info(volumeID, &info);
if (status != FSSH_B_OK)
return status;
printf("root inode: %" FSSH_B_PRIdINO "\n", info.root);
printf("flags: ");
print_flag(info.flags, FSSH_B_FS_HAS_QUERY, "Q", "-");
print_flag(info.flags, FSSH_B_FS_HAS_ATTR, "A", "-");
print_flag(info.flags, FSSH_B_FS_HAS_MIME, "M", "-");
print_flag(info.flags, FSSH_B_FS_IS_SHARED, "S", "-");
print_flag(info.flags, FSSH_B_FS_IS_PERSISTENT, "P", "-");
print_flag(info.flags, FSSH_B_FS_IS_REMOVABLE, "R", "-");
print_flag(info.flags, FSSH_B_FS_IS_READONLY, "-", "W");
printf("\nblock size: %" FSSH_B_PRIdOFF "\n", info.block_size);
printf("I/O size: %" FSSH_B_PRIdOFF "\n", info.io_size);
printf("total size: %s (%" FSSH_B_PRIdOFF " blocks)\n",
byte_string(info.total_blocks, info.block_size), info.total_blocks);
printf("free size: %s (%" FSSH_B_PRIdOFF " blocks)\n",
byte_string(info.free_blocks, info.block_size), info.free_blocks);
printf("total nodes: %" FSSH_B_PRIdOFF "\n", info.total_nodes);
printf("free nodes: %" FSSH_B_PRIdOFF "\n", info.free_nodes);
printf("volume name: %s\n", info.volume_name);
printf("fs name: %s\n", info.fsh_name);
return FSSH_B_OK;
}
void print_hdr(pkt *Pkt)
{
// printf("--HDR--\n");
printf("Seq: %u\n", Pkt->Hdr->seq);
printf("Checksum: %u\n", Pkt->Hdr->checksum);
printf("Flag: %u :: ", (uint32_t)Pkt->Hdr->flag);
print_flag(Pkt->Hdr->flag);
printf("\n");
}
inline void backto_os(){
init_flag_position();
__asm__("pop %si");
screen_init();
__asm__("pop %si");
print_welcome_msg();
__asm__("pop %si");
print_message();
__asm__("pop %si");
print_flag(); //root@wangqin4377@: position
__asm__("pop %si");
}
//--------------------------------- SHELL core os.c---------
char listen_key(){
// unsigned short int init_pos = get_pointer_pos();
flag_len=17;
char i = gets( key);
screen_sc_T = 1;
Print_flag_mark = 1;
if( strcmp( key, "clear\0")){ // char *,const char *
clear();
return i;
}
if( strcmp( key, "python\0")){
python();
Print_flag_mark = 1;
return i;
}
if( strcmp( key, "start\0")){
clear();
set_pointer_pos();
Print_flag_mark = 0;
Process();
return i;
}
if( strcmp( key, "help\0")){
//can't refer 2 two times, so...
init_flag_position();
screen_init();
print_welcome_msg();
print_message();
print_flag(); //root@wangqin4377@: position
return i;
}
//---------------------------------mark: man xxx, run xxx,asc xx...
if( synCheck( key, "run\0")){
run( key);
return i;
}
if( key[0] == '\0'){
return i;
}
flag_scroll();
set_pointer_pos();
print_str(" No such file or Directory", 27);
screen_sc_T = 2;
return i;
}
static void print_serial_flags(int serial_flags, enum print_mode mode,
const char *prefix, const char *postfix)
{
int i;
const char *spd, *pr;
pr = prefix;
spd = get_spd(serial_flags, mode);
if (spd)
print_flag(&pr, spd);
for (i = CMD_FLAG_FIRST; i <= CMD_FLAG_LAST; i++) {
if ((serial_flags & setbits[i])
&& (mode > PRINT_SUMMARY || !cmd_noprint(i))
) {
print_flag(&pr, nth_string(commands, i));
}
}
puts(pr == prefix ? "" : postfix);
}
int main(int argc, char *argv[])
{
srand(time(NULL));
long long number;
int moneys = 100;
long wager;
long long long_answer = ((long)rand() << 32) | (long)rand();
if (long_answer > 10) long_answer+=11;
puts("Lex Trebeq: And now it's time for Final Jeopardy!");
fflush(0);
sleep(3);
puts(" The current scores are: IBM Watson with $102,600, Stephen Hawking with $110,400, and YOU with an astonishing $100.");
fflush(0);
sleep(3);
puts(" The category is 'Numbers greater than 10'");
fflush(0);
sleep(3);
printf("Enter your answer: ");
fflush(0);
scanf("%lld", &number);
printf("Enter your wager: ");
fflush(0);
scanf("%ld", &wager);
if ((int)wager > 100 || wager < 0){
puts("You can't even bet that much money...");
return 0;
fflush(0);
}
dot_sleep(8);
puts("And the answers are in!");
fflush(0);
sleep(3);
if (number == long_answer){
puts("Wow good job you weren't even supposed to be able to do that!!");
moneys += wager;
} else {
moneys -= wager;
printf("I'm sorry %lld was not the right answer. It was actually %lld.\n", number, long_answer);
}
fflush(0);
sleep(3);
if (moneys <= 110400){
printf("It looks like despite your answer there was no way for you to win. You lose! (%d)", moneys);
} else {
dot_sleep(5);
printf("Although it looks like through some miracle, you have won with $%d... HOW DOES THAT WORK??\nAnyway you'll be going home with one of our fabulous FLAGS!!!!!\n", moneys);
sleep(5);
print_flag();
}
return 0;
}
static void dns_dump(const void *ip, const struct xt_entry_match *match) {
const struct xt_dns *dns = (struct xt_dns *)match->data;
print_flag("qr", dns->qr, XT_DNS_FLAG_QR, dns->invflags);
print_flag_opcode(dns->opcode, dns->setflags, dns->invflags);
print_flag("aa", dns->aa, XT_DNS_FLAG_AA, dns->invflags);
print_flag("tc", dns->tc, XT_DNS_FLAG_TC, dns->invflags);
print_flag("rd", dns->rd, XT_DNS_FLAG_RD, dns->invflags);
print_flag("ra", dns->ra, XT_DNS_FLAG_RA, dns->invflags);
print_flag("ad", dns->ad, XT_DNS_FLAG_AD, dns->invflags);
print_flag("cd", dns->cd, XT_DNS_FLAG_CD, dns->invflags);
print_flag_rcode(dns->rcode, dns->setflags, dns->invflags);
print_flag_qname(dns->qname, dns->setflags, dns->invflags);
print_flag_qtype(ntohs(dns->qtype), dns->setflags, dns->invflags);
print_flag("rmatch", dns->rmatch, XT_DNS_FLAG_RMATCH, dns->invflags);
print_maxsize(dns->maxsize, dns->invflags);
}
int main() {
char flag[MAX][MAX];
int ans;
ans= create_sweden(flag, H);
if (ans == 1)
ans= ans && (print_flag(flag, H, W) == 1);
if (ans != 1)
printf("Unexpected value returned.\n");
return 0;
}
void print_flags(u_int8_t flags) {
flag_count = 0;
if(flags & TH_FIN) print_flag("FIN");
if(flags & TH_SYN) print_flag("SYN");
if(flags & TH_RST) print_flag("RST");
if(flags & TH_PUSH) print_flag("PUSH");
if(flags & TH_ACK) print_flag("ACK");
if(flags & TH_URG) print_flag("URG");
}
/*once receive the search parameters from message 1
* we should print out the agent fd, threadid and options
*/
void print_search_para(int fd, search *mysearch) {
fprintf(stderr, "Client's Options, thread fd:%d thread id: %lu\n", fd,
(unsigned long) pthread_self());
print_flag(mysearch->options_flags, DOT_ACCESS, "-a");
print_flag(mysearch->options_flags, AT_BEGIN, "-b");
print_flag(mysearch->options_flags, AT_END, "-e");
print_flag(mysearch->options_flags, NOT_FOLLOW_LINK, "-f");
print_flag(mysearch->options_flags, CASE_INSENSITIVE, "-i");
print_flag(mysearch->options_flags, SHOW_PATH, "-p");
print_flag(mysearch->options_flags, NO_ERR_MSG, "-q");
print_flag(mysearch->options_flags, INVERSE_PRINT, "-i");
fprintf(stderr, "%s\t%d\n", "-d", mysearch->max_dir_depth);
fprintf(stderr, "%s\t%d\n", "-l",
mysearch->line_buffer_size == DEFAULT_LINE_BUFFER ?
-1 : mysearch->line_buffer_size);
fprintf(stderr, "%s\t%d\n", "-m", mysearch->max_line_number);
fprintf(stderr, "%s\t%d\n", "-n", mysearch->column_number);
fprintf(stderr, "%s\t%d\n", "-t", mysearch->thread_limits);
}
int main(int argc, char **argv) {
char pass[30];
int size = 0;
puts("Show me what you got !");
puts("Enter the password Morty : ");
size = read(0, pass, 29);
pass[size] = '\0';
if (verify_password(pass) == 0) {
puts("There you go!");
print_flag();
} else {
puts("Come on Morty, try harder");
}
return 0;
}
static void print_attrs(struct rtattr *attrs[])
{
print_flag(attrs, "protect", MACSEC_SECY_ATTR_PROTECT);
if (attrs[MACSEC_SECY_ATTR_VALIDATE]) {
__u8 val = rta_getattr_u8(attrs[MACSEC_SECY_ATTR_VALIDATE]);
print_string(PRINT_ANY, "validate",
"validate %s ", validate_str[val]);
}
print_flag(attrs, "sc", MACSEC_RXSC_ATTR_ACTIVE);
print_flag(attrs, "sa", MACSEC_SA_ATTR_ACTIVE);
print_flag(attrs, "encrypt", MACSEC_SECY_ATTR_ENCRYPT);
print_flag(attrs, "send_sci", MACSEC_SECY_ATTR_INC_SCI);
print_flag(attrs, "end_station", MACSEC_SECY_ATTR_ES);
print_flag(attrs, "scb", MACSEC_SECY_ATTR_SCB);
print_flag(attrs, "replay", MACSEC_SECY_ATTR_REPLAY);
if (attrs[MACSEC_SECY_ATTR_WINDOW]) {
__u32 win = rta_getattr_u32(attrs[MACSEC_SECY_ATTR_WINDOW]);
print_uint(PRINT_ANY, "window", "window %u ", win);
}
if (attrs[MACSEC_SECY_ATTR_CIPHER_SUITE]) {
__u64 cid = rta_getattr_u64(attrs[MACSEC_SECY_ATTR_CIPHER_SUITE]);
print_string(PRINT_FP, NULL, "%s", _SL_);
print_string(PRINT_ANY, "cipher_suite",
" cipher suite: %s,", cs_id_to_name(cid));
}
if (attrs[MACSEC_SECY_ATTR_ICV_LEN]) {
__u8 icv_len = rta_getattr_u8(attrs[MACSEC_SECY_ATTR_ICV_LEN]);
print_uint(PRINT_ANY, "icv_length",
" using ICV length %u\n", icv_len);
}
}
int main(int argc, char *argv[]) {
setvbuf(stdout, NULL, _IONBF, 0);
cash = get_rand();
puts("Welcome to ONLINE ROULETTE!");
printf("Here, have $%ld to start on the house! You'll lose it all anyways >:)\n", cash);
puts("");
long bet;
long choice;
while(cash > 0) {
bet = get_bet();
cash -= bet;
choice = get_choice();
puts("");
play_roulette(choice, bet);
if (wins >= MAX_WINS) {
printf("Wow you won %lu times? Looks like its time for you cash you out.\n", wins);
printf("Congrats you made $%lu. See you next time!\n", cash);
exit(-1);
}
if(cash > ONE_BILLION) {
printf("*** Current Balance: $%lu ***\n", cash);
if (wins >= HOTSTREAK) {
puts("Wow, I can't believe you did it.. You deserve this flag!");
print_flag();
exit(0);
}
else {
puts("Wait a second... You're not even on a hotstreak! Get out of here cheater!");
exit(-1);
}
}
}
puts("Haha, lost all the money I gave you already? See ya later!");
return 0;
}
void ft_base(t_dt *data)
{
static void (*func[])(t_dt *) = { PRINTF_FUNC1, PRINTF_FUNC2 };
char *ptr;
while (*data->tail)
{
if (*data->tail == '%')
{
ptr = NULL;
get_options(data);
if (*data->tail)
ptr = ft_strchr(PRINTF_ARGS, *data->tail);
(ptr) ? func[ptr - PRINTF_ARGS](data) : print_flag(data);
ft_memset(&data->flag, 0, sizeof(data->flag));
}
else
write_char(data, *data->tail);
data->tail++;
}
}
int main()
{
#ifdef NTL_SPMM_ULL
if (sizeof(NTL_ULL_TYPE) < 2*sizeof(long)) {
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
long n, k;
n = 200;
k = 10*NTL_ZZ_NBITS;
ZZ p;
RandomLen(p, k);
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i, j;
long iter;
const int nprimes = 30;
const long L = 12;
const long N = 1L << L;
long r;
for (r = 0; r < nprimes; r++) UseFFTPrime(r);
vec_long aa[nprimes], AA[nprimes];
for (r = 0; r < nprimes; r++) {
aa[r].SetLength(N);
AA[r].SetLength(N);
for (i = 0; i < N; i++)
aa[r][i] = RandomBnd(GetFFTPrime(r));
FFTFwd(AA[r].elts(), aa[r].elts(), L, r);
FFTRev1(AA[r].elts(), AA[r].elts(), L, r);
}
iter = 1;
do {
t = GetTime();
for (j = 0; j < iter; j++) {
for (r = 0; r < nprimes; r++) {
long *AAp = AA[r].elts();
long *aap = aa[r].elts();
long q = GetFFTPrime(r);
mulmod_t qinv = GetFFTPrimeInv(r);
FFTFwd(AAp, aap, L, r);
FFTRev1(AAp, aap, L, r);
for (i = 0; i < N; i++) AAp[i] = NormalizedMulMod(AAp[i], aap[i], q, qinv);
}
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((1.5/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (j = 0; j < iter; j++) {
for (r = 0; r < nprimes; r++) {
long *AAp = AA[r].elts();
long *aap = aa[r].elts();
long q = GetFFTPrime(r);
mulmod_t qinv = GetFFTPrimeInv(r);
FFTFwd(AAp, aap, L, r);
FFTRev1(AAp, aap, L, r);
for (i = 0; i < N; i++) AAp[i] = NormalizedMulMod(AAp[i], aap[i], q, qinv);
}
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e13);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int main()
{
#if (defined(NTL_CRT_ALTCODE) && !(defined(NTL_HAVE_LL_TYPE) && NTL_ZZ_NBITS == NTL_BITS_PER_LONG))
{
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
SetSeed(ZZ(0));
long n, k;
n = 1024;
k = 30*NTL_SP_NBITS;
ZZ p;
RandomLen(p, k);
if (!IsOdd(p)) p++;
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i;
long iter;
ZZ_pX a, b, c;
random(a, n);
random(b, n);
long da = deg(a);
long db = deg(b);
long dc = da + db;
long l = NextPowerOfTwo(dc+1);
FFTRep arep, brep, crep;
ToFFTRep(arep, a, l, 0, da);
ToFFTRep(brep, b, l, 0, db);
mul(crep, arep, brep);
ZZ_pXModRep modrep;
FromFFTRep(modrep, crep);
FromZZ_pXModRep(c, modrep, 0, dc);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
FromZZ_pXModRep(c, modrep, 0, dc);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((3/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
FromZZ_pXModRep(c, modrep, 0, dc);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e12);
// The following is just to test some tuning Wizard logic --
// be sure to get rid of this!!
#if (defined(NTL_CRT_ALTCODE))
// t *= 1.12;
#endif
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
void print_person( int reference, Str_prt_params *ps_ptr )
{
Person *pptr ;
Couple *cptr ;
short cblk ; /* block number */
int coup, father, mother, ch, spouse ;
/* references */
char *ch_ptr ; /* ptr to array of child refs */
char *coupls_ptr ; /* ptr to array of couplings */
short first_ch ; /* flag to print "sibling" or */
/* "children" before first one */
char temp_str[100] ;
short dist_down ;
short dummy ;
short omit_baptism_details = TRUE ;
short omit_will_details = TRUE ;
short omit_death_details = TRUE ;
short omit_wed_details ;
short omit_divorce_details ;
short i ;
busy( BUSY_MORE ) ;
pptr = get_pdata_ptr( reference, &dummy ) ;
ps_ptr->ref1 = reference ;
if( ps_ptr->use_gdos )
setup_font( ps_ptr, largefont ) ;
ps_ptr->last_x_end = 0 ;
ps_ptr->y_pos = 0 ;
ps_ptr->downlines = 1 ;
ps_ptr->tabpos = 0 ;
sprintf( temp_str, "%s %s", pptr->forenames, pptr->family_name ) ;
ps_ptr->align = RIGHT ;
ps_ptr->x_pos = ps_ptr->chs_across ;
print_str( NULL, 0, temp_str, 0, ps_ptr ) ;
ps_ptr->align = RIGHT ;
ps_ptr->x_pos = ps_ptr->chs_across ;
ps_ptr->tabpos = 0 ;
print_int( NULL, 0, pptr->reference, 0, ps_ptr ) ;
dist_down = ps_ptr->y_pos * ps_ptr->cell_height ;
if( ps_ptr->use_gdos ) setup_font( ps_ptr, fontinfo ) ;
ps_ptr->y_pos = ( dist_down + ps_ptr->cell_height - 1 )
/ ps_ptr->cell_height ;
ps_ptr->align = LEFT_WRAP ;
ps_ptr->x_pos = 0 ;
ps_ptr->max_len = 0 ;
ps_ptr->last_x_end = 0 ;
ps_ptr->tabpos = 28 ;
print_date( pers_form.fm_ptr, BIRTH_SOURCE, pptr->birth_date, 0, ps_ptr ) ;
// ps_ptr->align = LEFT_WRAP ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 24 ;
print_str( pers_form.fm_ptr, BIRTH_PLACE, pptr->birth_place, 1, ps_ptr ) ;
// ps_ptr->align = LEFT_WRAP ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 24 ;
// ps_ptr->downlines = 1 ;
print_str( birth_form.fm_ptr, BI_SOURCE_TITLE, pptr->birth_source, 1, ps_ptr ) ;
if( pptr->occupation ) down_n_lines( 1, ps_ptr ) ;
ps_ptr->x_pos = 0 ;
ps_ptr->tabpos = 28 ;
print_str( pers_form.fm_ptr, OCCUPATION, pptr->occupation, 1, ps_ptr ) ;
down_n_lines( 1, ps_ptr ) ;
if( coup = pptr->parents )
{
father = couples[coup].male_reference ;
names_ref( father, temp_str, 40, FALSE ) ;
/* format names into string */
ps_ptr->x_pos = 0 ;
ps_ptr->tabpos = 28 ;
print_str( pers_form.fm_ptr, FATHER, temp_str, 0, ps_ptr ) ;
mother = couples[coup].female_reference ;
names_ref( mother, temp_str, 40, FALSE ) ;
/* format names into string */
print_str( pers_form.fm_ptr, MOTHER, temp_str, 0, ps_ptr ) ;
cptr = get_cdata_ptr( coup, &cblk ) ;
if( ch_ptr = cptr->children )
{
first_ch = TRUE ;
while( ch = form_ref( &ch_ptr ) )
{
if( ch != reference )
{
if( first_ch )
{
first_ch = FALSE ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 0 ;
print_str( pers_form.fm_ptr, SIB_STRING, NULL, 0, ps_ptr ) ;
ps_ptr->x_pos = 28 ;
}
names_ref( ch, temp_str, 40, FALSE ) ;
print_str( NULL, 0, temp_str, 0, ps_ptr ) ;
}
}
}
if( ps_ptr->y_pos < printer_lines ) down_n_lines( 1, ps_ptr ) ;
}
if( pptr->baptism_date || pptr->baptism_place || pptr->baptism_source )
omit_baptism_details = FALSE ;
ps_ptr->x_pos = 0 ;
ps_ptr->tabpos = 28 ;
print_date( pers_form.fm_ptr, BAPTISM, pptr->baptism_date,
omit_baptism_details, ps_ptr ) ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 24 ;
print_str( baptism_form.fm_ptr, BA_PLACE, pptr->baptism_place, 1, ps_ptr ) ;
print_str( baptism_form.fm_ptr, BA_SOURCE, pptr->baptism_source, 1, ps_ptr ) ;
if( !omit_baptism_details )
if( ps_ptr->y_pos < printer_lines ) down_n_lines( 1, ps_ptr ) ;
if( coupls_ptr = pptr->couplings )
{
while( coup = form_ref( &coupls_ptr ) )
{
omit_wed_details = TRUE ;
omit_divorce_details = TRUE ;
cptr = get_cdata_ptr( coup, &cblk ) ;
if( cptr->male_reference == reference )
spouse = cptr->female_reference ;
else spouse = cptr->male_reference ;
names_ref( spouse, temp_str, 40, FALSE ) ;
ps_ptr->x_pos = 0 ;
ps_ptr->tabpos = 28 ;
print_str( pers_form.fm_ptr, SPOUSE, temp_str, 0, ps_ptr ) ;
if( cptr->wedding_date || cptr->wedding_place || cptr->wedding_place
|| cptr->wedd_wit1 || cptr->wedd_wit2 )
omit_wed_details = FALSE ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 24 ;
print_date( coup_form.fm_ptr, C_SOURCE, cptr->wedding_date,
omit_wed_details, ps_ptr ) ;
print_str( coup_form.fm_ptr, W_PLACE, cptr->wedding_place, 1, ps_ptr ) ;
print_str( co_src_form.fm_ptr, W_SOURCE, cptr->wedding_source, 1, ps_ptr ) ;
ps_ptr->x_pos = 8 ;
ps_ptr->tabpos = 20 ;
print_str( co_src_form.fm_ptr, WWIT1, cptr->wedd_wit1, 1, ps_ptr ) ;
print_str( co_src_form.fm_ptr, WWIT2, cptr->wedd_wit2, 1, ps_ptr ) ;
if( cptr->divorce_date || cptr->divorce_source )
omit_divorce_details = FALSE ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 24 ;
print_date( coup_form.fm_ptr, C_DIVORCE, cptr->divorce_date,
omit_divorce_details, ps_ptr ) ;
ps_ptr->x_pos = 8 ;
ps_ptr->tabpos = 20 ;
print_str( divorce_form.fm_ptr, DI_SOURCE_TITLE, cptr->divorce_source, 1, ps_ptr ) ;
if( ch_ptr = cptr->children )
{
first_ch = TRUE ;
while( ch = form_ref( &ch_ptr ) )
{
if( first_ch )
{
first_ch = FALSE ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 0 ;
print_str( pers_form.fm_ptr, CH_STRING, NULL, 0, ps_ptr ) ;
ps_ptr->x_pos = 28 ;
}
names_ref( ch, temp_str, 40, FALSE ) ;
print_str( NULL, 0, temp_str, 0, ps_ptr ) ;
}
}
if( ps_ptr->y_pos < printer_lines ) down_n_lines( 1, ps_ptr ) ;
}
}
if( pptr->will_date || pptr->will_wit1 || pptr->will_wit2
|| pptr->will_exe1 || pptr->will_exe2
|| pptr->will_sol || pptr->will_bens
|| pptr->will_bens2 || pptr->will_bens3 )
omit_will_details = FALSE ;
if( pptr->death_date || pptr->death_place || pptr->death_source
|| pptr->burial_date || pptr->burial_place || !omit_will_details )
omit_death_details = FALSE ;
ps_ptr->x_pos = 0 ;
ps_ptr->tabpos = 28 ;
print_date( pers_form.fm_ptr, DEATH, pptr->death_date,
omit_death_details, ps_ptr ) ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 24 ;
print_str( death_form.fm_ptr, D_PLACE, pptr->death_place, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, BC_PLACE, pptr->burial_place, 1, ps_ptr ) ;
print_date( death_form.fm_ptr, BCDATE, pptr->burial_date, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, D_SOURCE, pptr->death_source, 1, ps_ptr ) ;
print_date( death_form.fm_ptr, D_WILL, pptr->will_date, omit_will_details,
ps_ptr ) ;
ps_ptr->x_pos = 8 ;
ps_ptr->tabpos = 20 ;
print_str( death_form.fm_ptr, DWIT1, pptr->will_wit1, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, DWIT2, pptr->will_wit2, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, EXEC1, pptr->will_exe1, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, EXEC2, pptr->will_exe2, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, SOLIC, pptr->will_sol, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, BENEF, pptr->will_bens, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, BENEF2, pptr->will_bens2, 1, ps_ptr ) ;
print_str( death_form.fm_ptr, BENEF3, pptr->will_bens3, 1, ps_ptr ) ;
ps_ptr->x_pos = 4 ;
ps_ptr->tabpos = 24 ;
for( i=7; i>=0; i-- ) print_flag( i, pptr->flags, ps_ptr ) ;
if( pptr->notes )
{
ps_ptr->tabpos = 0 ;
ps_ptr->x_pos = 0 ;
// ps_ptr->downlines = 1 ;
ps_ptr->align = LEFT ;
print_str( NULL, 0, NULL, 0, ps_ptr ) ;
ps_ptr->downlines = 2 ;
print_str( pers_form.fm_ptr, NOTES, NULL, 0, ps_ptr ) ;
print_notes_indented( pptr, ps_ptr ) ;
}
end_page( ps_ptr, FALSE ) ;
busy( BUSY_LESS ) ;
}
int main()
{
long n, i, j, iter, s, k;
double t;
for (i = 0; i < 10000; i++) {
GF2X a, b, c, d;
long da = RandomBnd(5*NTL_BITS_PER_LONG);
long db = RandomBnd(5*NTL_BITS_PER_LONG);
long dc = RandomBnd(5*NTL_BITS_PER_LONG);
long dd = RandomBnd(5*NTL_BITS_PER_LONG);
random(a, da); random(b, db); random(c, dc); random(d, dd);
if ((a + b)*(c + d) != c*a + d*a + c*b + d*b) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
n = 16;
s = 56;
GF2X *a = new GF2X[s];
GF2X *b = new GF2X[s];
GF2X c;
for (k = 0; k < s; k++) {
random(a[k], (n + (k % 7))*NTL_BITS_PER_LONG);
random(b[k], (n + (k % 8))*NTL_BITS_PER_LONG);
}
for (k = 0; k < s; k++) mul(c, a[k], b[k]);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 1; j++) for (k = 0; k < s; k++) mul(c, a[k], b[k]);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((2/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 1; j++) for (k = 0; k < s; k++) mul(c, a[k], b[k]);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e14);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
int
main (int argc, char **argv)
{
int i, col, r;
const char *name = "ucl_chartable";
bool need_or;
char valbuf[2048];
col = 0;
if (argc > 1) {
name = argv[1];
}
printf ("static const unsigned int %s[256] = {\n", name);
for (i = 0; i < 256; i ++) {
need_or = false;
r = 0;
/* UCL_CHARACTER_VALUE_END */
if (i == ' ' || i == '\t') {
r += print_flag ("UCL_CHARACTER_WHITESPACE", &need_or, valbuf + r);
}
if (isspace (i)) {
r += print_flag ("UCL_CHARACTER_WHITESPACE_UNSAFE", &need_or, valbuf + r);
}
if (isalnum (i) || i >= 0x80 || i == '/' || i == '_') {
r += print_flag ("UCL_CHARACTER_KEY_START", &need_or, valbuf + r);
}
if (isalnum (i) || i == '-' || i == '_' || i == '/' || i == '.' || i >= 0x80) {
r += print_flag ("UCL_CHARACTER_KEY", &need_or, valbuf + r);
}
if (i == 0 || i == '\r' || i == '\n' || i == ']' || i == '}' || i == ';' || i == ',' || i == '#') {
r += print_flag ("UCL_CHARACTER_VALUE_END", &need_or, valbuf + r);
}
else {
if (isprint (i) || i >= 0x80) {
r += print_flag ("UCL_CHARACTER_VALUE_STR", &need_or, valbuf + r);
}
if (isdigit (i) || i == '-') {
r += print_flag ("UCL_CHARACTER_VALUE_DIGIT_START", &need_or, valbuf + r);
}
if (isalnum (i) || i == '.' || i == '-' || i == '+') {
r += print_flag ("UCL_CHARACTER_VALUE_DIGIT", &need_or, valbuf + r);
}
}
if (i == '"' || i == '\\' || i == '/' || i == 'b' ||
i == 'f' || i == 'n' || i == 'r' || i == 't' || i == 'u') {
r += print_flag ("UCL_CHARACTER_ESCAPE", &need_or, valbuf + r);
}
if (i == ' ' || i == '\t' || i == ':' || i == '=') {
r += print_flag ("UCL_CHARACTER_KEY_SEP", &need_or, valbuf + r);
}
if (i == '\n' || i == '\r' || i == '\\' || i == '\b' || i == '\t' ||
i == '"' || i == '\f') {
r += print_flag ("UCL_CHARACTER_JSON_UNSAFE", &need_or, valbuf + r);
}
if (i == '\n' || i == '\r' || i == '\\' || i == '\b' || i == '\t' ||
i == '"' || i == '\f' || i == '=' || i == ':' || i == '{' || i == '[' || i == ' ') {
r += print_flag ("UCL_CHARACTER_UCL_UNSAFE", &need_or, valbuf + r);
}
if (!need_or) {
r += print_flag ("UCL_CHARACTER_DENIED", &need_or, valbuf + r);
}
if (isprint (i)) {
r += sprintf (valbuf + r, " /* %c */", i);
}
if (i != 255) {
r += sprintf (valbuf + r, ", ");
}
col += r;
if (col > 80) {
printf ("\n%s", valbuf);
col = r;
}
else {
printf ("%s", valbuf);
}
}
printf ("\n}\n");
return 0;
}
int main()
{
#ifdef NTL_LONG_LONG
if (sizeof(NTL_LL_TYPE) < 2*sizeof(long)) {
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
SetSeed(ZZ(0));
long i, k;
k = 10*NTL_ZZ_NBITS;
for (i = 0; i < 10000; i++) {
ZZ a, b, c, d;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k);
long dd = RandomBnd(k);
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc); RandomLen(d, dd);
if ((a + b)*(c + d) != c*a + d*a + c*b + d*b) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
for (i = 0; i < 10000; i++) {
ZZ a, b, c;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k) + 2;
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc);
if ( ( a * b ) % c != ((a % c) * (b % c)) % c ) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
k = 1024;
ZZ x1, x2, x3;
double t;
long j;
RandomLen(x1, k);
RandomLen(x2, k);
long iter;
mul(x3, x1, x2);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((3/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e14);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
/* device creation */
static void macsec_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
{
if (!tb)
return;
if (tb[IFLA_MACSEC_SCI]) {
if (is_json_context()) {
SPRINT_BUF(b1);
snprintf(b1, sizeof(b1), "%016llx",
ntohll(rta_getattr_u64(tb[IFLA_MACSEC_SCI])));
print_string(PRINT_JSON, "sci", NULL, b1);
} else {
fprintf(f, "sci %016llx ",
ntohll(rta_getattr_u64(tb[IFLA_MACSEC_SCI])));
}
}
print_flag(tb, "protect", IFLA_MACSEC_PROTECT);
if (tb[IFLA_MACSEC_CIPHER_SUITE]) {
__u64 csid
= rta_getattr_u64(tb[IFLA_MACSEC_CIPHER_SUITE]);
print_string(PRINT_ANY,
"cipher_suite",
"cipher %s ",
cs_id_to_name(csid));
}
if (tb[IFLA_MACSEC_ICV_LEN]) {
if (is_json_context()) {
char b2[4];
snprintf(b2, sizeof(b2), "%hhu",
rta_getattr_u8(tb[IFLA_MACSEC_ICV_LEN]));
print_uint(PRINT_JSON, "icv_len", NULL, atoi(b2));
} else {
fprintf(f, "icvlen %hhu ",
rta_getattr_u8(tb[IFLA_MACSEC_ICV_LEN]));
}
}
if (tb[IFLA_MACSEC_ENCODING_SA]) {
if (is_json_context()) {
char b2[4];
snprintf(b2, sizeof(b2), "%hhu",
rta_getattr_u8(tb[IFLA_MACSEC_ENCODING_SA]));
print_uint(PRINT_JSON, "encoding_sa", NULL, atoi(b2));
} else {
fprintf(f, "encodingsa %hhu ",
rta_getattr_u8(tb[IFLA_MACSEC_ENCODING_SA]));
}
}
if (tb[IFLA_MACSEC_VALIDATION]) {
__u8 val = rta_getattr_u8(tb[IFLA_MACSEC_VALIDATION]);
print_string(PRINT_ANY,
"validation",
"validate %s ",
validate_str[val]);
}
const char *inc_sci, *es, *replay;
if (is_json_context()) {
inc_sci = "inc_sci";
replay = "replay_protect";
es = "es";
} else {
inc_sci = "send_sci";
es = "end_station";
replay = "replay";
}
print_flag(tb, "encrypt", IFLA_MACSEC_ENCRYPT);
print_flag(tb, inc_sci, IFLA_MACSEC_INC_SCI);
print_flag(tb, es, IFLA_MACSEC_ES);
print_flag(tb, "scb", IFLA_MACSEC_SCB);
print_flag(tb, replay, IFLA_MACSEC_REPLAY_PROTECT);
if (tb[IFLA_MACSEC_WINDOW])
print_int(PRINT_ANY,
"window",
"window %d ",
rta_getattr_u32(tb[IFLA_MACSEC_WINDOW]));
}
int main()
{
_newntl_gmp_hack = 0;
long n, k;
n = 200;
k = 10*newNTL_ZZ_NBITS;
ZZ p;
RandomLen(p, k);
ZZ_p::init(p); // initialization
ZZ_pX f, g, h, r1, r2, r3;
random(g, n); // g = random polynomial of degree < n
random(h, n); // h = " "
random(f, n); // f = " "
SetCoeff(f, n); // Sets coefficient of X^n to 1
// For doing arithmetic mod f quickly, one must pre-compute
// some information.
ZZ_pXModulus F;
build(F, f);
PlainMul(r1, g, h); // this uses classical arithmetic
PlainRem(r1, r1, f);
MulMod(r2, g, h, F); // this uses the FFT
MulMod(r3, g, h, f); // uses FFT, but slower
// compare the results...
if (r1 != r2) {
printf("999999999999999 ");
print_flag();
return 0;
}
else if (r1 != r3) {
printf("999999999999999 ");
print_flag();
return 0;
}
double t;
long i;
long iter;
n = 1024;
k = 1024;
RandomLen(p, k);
ZZ_p::init(p);
ZZ_pX j1, j2, j3;
random(j1, n);
random(j2, n);
mul(j3, j1, j2);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
FFTMul(j3, j1, j2);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((2/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
FFTMul(j3, j1, j2);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e12);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
//--------------------------------- SHELL core os.c---------
char listen_key(){
// unsigned short int init_pos = get_pointer_pos();
flag_len=17;
char i = gets( key);
screen_sc_T = 1;
Print_flag_mark = 1;
if( strcmp( key, "clear\0")){ // char *,const char *
clear();
return i;
}
if( strcmp( key, "time\0")){
time();
return i;
}
if( strcmp( key, "date\0")){
date();
return i;
}
if( strcmp( key, "python\0")){
python();
return i;
}
if( strcmp( key, "start\0")){
screen_init();
Print_flag_mark = 0;
Process();
return i;
}
if( strcmp( key, "help\0")){
//can't refer 2 two times, so...
init_flag_position();
screen_init();
print_welcome_msg();
print_message();
print_flag(); //root@wangqin4377@: position
return i;
}
//---------------------------------mark: man xxx, run xxx,asc xx...
if( synCheck( key, "asc\0")){
asc( key);
return i;
}
if( synCheck( key, "man\0")){
man( key);
return i;
}
if( synCheck( key, "run\0")){
run( key);
return i;
}
if( synCheck( key, "syscall\0")){
syscall_test();
return i;
}
if( synCheck( key, "int\0")){
if( strcmp( key, "int 33h")){
__asm__( "int $0x33");
return i;
}
if( strcmp( key, "int 34h")){
__asm__( "int $0x34");
return i;
}
if( strcmp( key, "int 35h")){
__asm__( "int $0x35");
return i;
}
if( strcmp( key, "int 36h")){
__asm__( "int $0x36");
return i;
}
}
if( key[0] == '\0'){
return i;
}
flag_scroll();
set_pointer_pos();
print_str(" No such file or Directory", 27);
screen_sc_T = 2;
return i;
}
int main(int argc, char *argv[])
{
srand(time(NULL));
bool giveme = false;
long zero = 0;
char buf[100];
bool gotflag = false;
puts("Welcome to hell, we have real strong JumpFu here");
start:
DBUG("start")
puts("Where to?");
fflush(0);
zero = 0;
fgets(buf, 117, stdin);
buf[99] = 0;
if (strncmp(buf+10, "WHO GOES THERE", strlen("WHO GOES THERE")) == 10)
goto six;
else
goto two;
one:
DBUG("one")
puts("WELCOME BACK");
goto start;
two:
DBUG("two")
puts("Who are you? Where are you even going?");
fflush(0);
if (buf[69]=='8')
goto eleven;
if (buf[69]=='9')
goto five;
goto one;
three:
DBUG("three")
puts("Here we go again...");
fflush(0);
goto eight;
four:
DBUG("four")
if (!zero)
goto nine;
five:
DBUG("five")
giveme = true;
if (!zero)
goto eight;
six:
DBUG("six")
giveme = false;
seven: //lucky number seven
DBUG("seven")
if (giveme){
gotflag = true;
print_flag();
goto end;
}else{
puts("NO!!! GO AWAY");
fflush(0);
}
eight:
DBUG("eight")
puts("Goodnight! See you later!");
fflush(0);
sleep(1);
if (rand() % 2)
goto one;
else
goto twelve;
nine:
DBUG("nine")
goto two;
ten:
DBUG("ten")
if (!zero)
goto end;
goto one;
eleven:
DBUG("eleven")
if (strncmp(&zero, "risky!", strlen("risky")))
goto eight;
goto six;
twelve:
DBUG("twelve")
if (zero)
goto seven;
else
goto ten;
end:
DBUG("end")
if (!gotflag)
puts("Looks like you are leavin here empty handed.");
else
puts("Nice work. You won.");
fflush(0);
return 0;
}
