// TODO: rewrite me
function solve(solution) { // ax+b = 0
  var vala, valb;

  const n = (err, v) => {
    if ( err )
      math('-', v, n);
    else
      solution(v);
  }
  const AdivB = (err, d) => {
    if ( err )
      math('/', vala, valb, AdivB);
    else
      math('-', d, n);
  }
  const cbb = (err, b) => {
    if (err)
      math('b', cbb);
    else {
      valb = b;
      if (vala != 0) math('/', vala, valb, AdivB);
      else solution(b == 0 ? [] : null);
    }
  }
  const cba = (err, a) => {
    if (err)
      math('a', cba);
    else {
      vala = a;
      math('b', cbb);
    }
  }
  math('a', cba);
}

function math(what, ...args_) {
  var vars = {a: 3, b: 2};

  if(!args_.length) throw new Error('Callback not found!');
  var args = args_.slice(0, -1), cb = args_[args.length];
  function pass(error, value) {
    // An AJAX request to a real server could be here.
    if(Math.random() < 0.2) {
      error = new Error('Network error');
      value = null;
    }
    setTimeout(cb.bind(null, error, value), 500 + Math.random() * 500 | 0);
  }
  switch(what) {
    case 'a':
    case 'b':
      pass(null, vars[what]);
      break;
    case '/':
      if(args.length < 2) pass(new Error('Not enough arguments'));
      else pass(null, args[0] / args[1]);
      break;
    case '-':
      if(args.length < 1) pass(new Error('Not enough arguments'));
      else pass(null, -args[0]);
      break;
    default:
      pass(new Error('Invalid command'));
  }
}



function solvep(solution) {
  var va = null, vb = null, div, ans;

  const f = (...args) => new Promise((success, error) => {
    var args_ = args.slice(1);
    args_.push((err, a) => { if (err) error(...args); else success(a); });
    math(args[0], ...args_);
  });

  const neg = () => new Promise ((success, error) => {
      if ( div === null || div === [] )
        success(div);
      else
        f('-', div).then((n) => { ans = n; success(ans); }, f);
    });

  const getAdivB = () => new Promise ((success, error) => {
      if ( va == 0 ) div = null;
      if ( va == 0 && vb == 0 ) div = [];
      if ( va == 0 )
        success();
      else
        f('/', va, vb).then( (d) =>{ div = d; success(); }, f);
    });

  const getAB = () => new Promise((success, error) =>
    Promise.all([f('a'), f('b')]).then((v) => { va = v[0]; vb = v[1]; success(); } )
  );

  getAB().then(getAdivB).then(neg).then(solution);
}

async function solvea() {

  const f = (...args) => new Promise((success, error) => {
    var args_ = args.slice(1);
    args_.push((err, a) => { if (err) error(...args); else success(a); });
    math(args[0], ...args_);
  });

  const neg = (div) => new Promise ((success, error) => {
      if ( div === null || div === [] )
        success(div);
      else
        f('-', div).then((n) => success(n), f);
    });

  const getAdivB = (a, b) => new Promise ((success, error) => {
    var dv;
      if ( a == 0 ) d = null;
      if ( a == 0 && b == 0 ) dv = [];
      if ( a == 0 )
        success(dv);
      else
        f('/', a, b).then( (d) => success(d), f);
    });

  const get = (p) => new Promise((success, error) => {
    f(p).then((a) => success(a), f)
  });

  va = get('a');
  vb = get('b');
  va = await va;
  vb = await vb;
  div = await getAdivB(va, vb);
  ans = await neg(div);
  return ans;
}