flockonus

const fs = require('fs').promises;
const path = require('path');

async function getFolderSize(folderPath) {
    let totalSize = 0;

    async function calculateSize(currentPath) {
        const files = await fs.readdir(currentPath, { withFileTypes: true });

        for (const file of files) {

flockonus

flockonus

[
  {
    "inputs": [
      {
        "internalType": "string",
        "name": "name",
        "type": "string"
      },
      {
        "internalType": "string",

flockonus

flockonus

d = {
  "data": {
    "points": {
      "1367193600": {
        "v": [
          144.5399932861328,
          0,
          1603768864.5,
          1,
          11095675.5153929

flockonus

//https://tools.ietf.org/id/draft-msporny-base58-01.html
// N=10, search space = 4e17
// N=18, search space = 5e31


function rand58(length) {
  const base = ('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz').split('')
  return Array.call(null, length).fill(0).map(() => base[Math.floor(Math.random() * 1e9) % base.length]).join('')
}

flockonus

const sleep = (seconds) => {
  return new Promise((accept) =>
    setTimeout(accept, seconds * 1000, `slept ${seconds}`),
  );
};

async function execParallel() {
  console.log(new Date(), 'starting');
  // promises will execute concurrently, so that execution time = slowest one (not the sum)
  const out = await Promise.all([sleep(5), sleep(5), sleep(5)]);

flockonus

package main

import (
	"log"
	"time"
)

type Kitty struct {
	id    uint
	owner string

flockonus

from threading import Thread
from queue import Queue
import time

num_worker_threads = 1

print("start", time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))

def task(item):
    print("IN", item)

flockonus

/// @dev given a number get a slice of any bits, at certain offset
/// @param _n a number to be sliced
/// @param _nbits how many bits long is the new number
/// @param _offset how many bits to skip
function _sliceNumber(uint256 _n, uint256 _nbits, uint256 _offset) private pure returns (uint256) {
    // mask is made by shifting left an offset number of times
    uint256 mask = uint256((2**_nbits) - 1) << _offset;
    // AND n with mask, and trim to max of _nbits bits
    return uint256((_n & mask) >> _offset);
}