static void check_sha1(const uint8_t *data,
size_t len,
const uint8_t expected[SHA1_DIGEST_LENGTH])
{
uint8_t digest[SHA1_DIGEST_LENGTH];
sha1_Raw(data, len, digest);
if (0 != memcmp(digest, expected, sizeof(digest))) {
printf("SHA1 for msg 0x%02x%02x... (len %d) broken\n",
data[0], data[1], (int )len);
printf(" expect: "); print_n(expected, SHA1_DIGEST_LENGTH); printf("\n");
printf(" actual: "); print_n(digest, SHA1_DIGEST_LENGTH); printf("\n");
abort();
}
}
void
string_param::
print_n(T0 const& t0, TN const&... tn)
{
print_1(t0);
print_n(tn...);
}
void print_n(int n){
if(n!=1){
print_n(n-1);
}
printf("%d\n",n);
}
static void print_from_base58(const char *str)
{
cstring *out_str = base58_decode(str);
/* *out= out_str->str; */
/* *out_len = out_str->len; */
print_n(out_str->str, out_str->len);
cstr_free(out_str, true);
}
static void print_ek_public(const struct hd_extended_key *ek)
{
printf(" version : 0x%08x\n", ek->version);
printf(" depth : %d\n", ek->depth);
printf(" parent : 0x");
print_n(ek->parent_fingerprint, 4); NEWLINE;
printf(" index : %d\n", ek->index);
printf(" chaincode : ");
print_n(ek->chaincode.data, 32); NEWLINE;
void *pub;
size_t pub_len = 0;
bp_pubkey_get(&ek->key, &pub, &pub_len);
printf(" pub key : ");
print_n(pub, pub_len); NEWLINE;
free(pub);
}
int main()
{
// Initialize the lookup.
for (int i = 0 ; i < BASE; i++)
{
int sum = 0;
int ii = i;
while (ii)
{
sum += ii % 10;
ii /= 10;
}
lookup[i] = sum;
}
#if 0
const long long LIM = 1000000;
#else
const long long LIM = 1000000000000000;
#endif
const long long STEP = 1000000000;
long long checkpoint = STEP;
for (;idx < LIM;idx++)
{
if (idx == checkpoint)
{
print_n();
checkpoint += STEP;
}
ull copy = digits;
while (copy)
{
digits += lookup[ copy % BASE];
copy /= BASE;
}
}
print_n();
return 0;
}
void
string_param::
print(T0 const& t0, T1 const& t1, TN const&... tn)
{
os_.emplace(buf_, sizeof(buf_));
print_1(t0);
print_1(t1);
print_n(tn...);
os_->flush();
sv_ = os_->str();
}
int main() {
node *constant;
node *print;
int value;
constant = constant_n(500);
print = print_n(constant);
ex(print);
return 0;
}
static void flush_line (void) {
unsigned i;
unsigned limit = (0 == n % line_length ? line_length : n % line_length);
for (i = 0; i < limit; ++i) {
if (0 == i % 8)
must_printf (" ");
must_printf (" %02x", 0xFF & line[i]);
}
must_printf ("\n");
print_n ();
}
void real_main (int argc, char *const argv[]) {
int i = 1;
print_n ();
if (i == argc)
xd (stdin, NULL);
else
for (; i < argc; ++i) {
FILE *in = must_fopen (argv[i], "r");
xd (in, argv[i]);
must_fclose (in, argv[i]);
}
finish ();
}
static void print_from_base58_key(const char *str)
{
cstring *out_str = base58_decode(str);
/* *out= out_str->str; */
/* *out_len = out_str->len; */
uint8_t *d = (uint8_t *)(out_str->str);
print_n(d, 4); SPACE; // version
print_n(d + 4, 1); SPACE; // depth
print_n(d + 5, 4); SPACE; // parent fingerprint
print_n(d + 9, 4); SPACE; // idx
print_n(d + 13, 32); SPACE; // chain code
print_n(d + 45, 33); SPACE; // key
/* print_n(out_str->str, out_str->len); */
cstr_free(out_str, true);
}
void print_64(const void *data)
{
print_n(data, 64);
}
int main(){
print_n(7);
return 0;
}
