TODO: Test this impl
197055
function getBlacklist(cb) {
  https.get(url, onRequest);

  function onRequest(res) {
    /* istanbul ignore if */
    if (res.statusCode !== 200) {
      // TODO: Test different status codes
      return cb(new Error('Request failed. Status Code: ' + res.statusCode));
    }

    res.setEncoding('utf8');

    collect(res, onCollect);
  }

  function onCollect(err, result) {
    /* istanbul ignore if */
    if (err) {
      return cb(err);
    }

    parse(result, onParse);
  }

  function onParse(err, blacklist) {
    /* istanbul ignore if */
    if (err) {
      return cb(err);
    }

    cb(null, blacklist);
  }
}
570183
function itl(params) {
  return init()
    .then(test)
    .then(() => logins(params))
    .catch(() =>
      associate()
        .then(() => logins(params))
    );
}
383930
public static <K, M extends Message>
      ListMultimapWithProtoValuesSubject<?, K, M, ListMultimap<K, M>> assertThat(
          @NullableDecl ListMultimap<K, M> listMultimap) {
    return assertAbout(protos()).that(listMultimap);
  }
713809
void createImpl() throws SocketException {
        if (impl == null)
            setImpl();
        try {
            impl.create(true);
            created = true;
        } catch (IOException e) {
            throw new SocketException(e.getMessage());
        }
    }
65233
function(callback, ctx){
      var k = 0;

      // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
      var O = Object(this);

      var len = O.length >>> 0; 

      if ( typeof callback !== "function" ) {
        throw new TypeError( callback + " is not a function" );
      }

      // 7. Repeat, while k < len
      while( k < len ) {

        var kValue;

        if ( k in O ) {

          kValue = O[ k ];

          callback.call( ctx, kValue, k, O );
        }
        k++;
      }
    }
739787
function() {
        if (this.explicit) {
            return this.valid;
        } else if (this.causedBy === undefined || this.causedBy.length == 0) {
            return undefined;
        } else {
            var valid,
                causes = this.causedBy,
                explicitFact;
            for (var i = 0; i < causes.length; i++) {
                valid = true;
                for (var j = 0; j < causes[i].length; j++) {
                    explicitFact = causes[i][j];
                    valid = valid && explicitFact.valid;
                }
                if (valid) {
                    return true;
                }
            }
            return false;
        }
    }
219792
public boolean compareAndPut(V testValue, K key, V value)
  {
    V result = compareAndPut(testValue, key, value, true);

    return testValue == result;
  }
173945
public static boolean argEquals(LToSrtBiFuncMemento the, Object that) {
		return Null.<LToSrtBiFuncMemento> equals(the, that, (one, two) -> {
			if (one.getClass() != two.getClass()) {
				return false;
			}

			LToSrtBiFuncMemento other = (LToSrtBiFuncMemento) two;

			return LObjSrtPair.argEquals(one.function, one.lastValue(), other.function, other.lastValue());
		});
	}
313597
@SuppressWarnings("unchecked")
    // Safe because impl never uses a parameter or returns any non-null value
    private static <K, V> ValueReference<K, V> computing() {
        return (ValueReference<K, V>) COMPUTING;
    }
1251684
function devModeEqual(a, b) {
    var /** @type {?} */ isListLikeIterableA = isListLikeIterable(a);
    var /** @type {?} */ isListLikeIterableB = isListLikeIterable(b);
    if (isListLikeIterableA && isListLikeIterableB) {
        return areIterablesEqual(a, b, devModeEqual);
    }
    else {
        var /** @type {?} */ isAObject = a && (typeof a === 'object' || typeof a === 'function');
        var /** @type {?} */ isBObject = b && (typeof b === 'object' || typeof b === 'function');
        if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {
            return true;
        }
        else {
            return looseIdentical(a, b);
        }
    }
}
98949
function (/*util*/) {

      function compare(actual, expected) {
        return {
          pass: actual instanceof Error && ('' + actual).indexOf(expected) >= 0
        }
      }

      return {compare: compare}
    }
357311
public static boolean argEquals(LDblToByteFuncMemento the, Object that) {
		return Null.<LDblToByteFuncMemento> equals(the, that, (one, two) -> {
			if (one.getClass() != two.getClass()) {
				return false;
			}

			LDblToByteFuncMemento other = (LDblToByteFuncMemento) two;

			return LObjBytePair.argEquals(one.function, one.lastValue(), other.function, other.lastValue());
		});
	}
184700
function(type, desc){
        this.assert(
            type == typeof this.obj
            , function(){ return 'expected ' + this.inspect + ' to be a ' + type + (desc ? " | " + desc : "") }
            , function(){ return 'expected ' + this.inspect + ' not to be a ' + type  + (desc ? " | " + desc : "") })
        return this;
    }
995041
public static boolean argEquals(LToIntFuncDelta the, Object that) {
		return Null.<LToIntFuncDelta> equals(the, that, (one, two) -> {
			if (one.getClass() != two.getClass()) {
				return false;
			}

			LToIntFuncDelta other = (LToIntFuncDelta) two;

			return LBiObjIntTriple.argEquals(one.function, one.deltaFunction, one.lastValue(), other.function, other.deltaFunction, other.lastValue());
		});
	}
740793
public static boolean equal(Object thisObject, Object thatObject) {
        return thisObject == null ? thatObject == null : thisObject.equals(thatObject);
    }
324379
public static boolean argEquals(LToLongBiFuncMemento the, Object that) {
		return Null.<LToLongBiFuncMemento> equals(the, that, (one, two) -> {
			if (one.getClass() != two.getClass()) {
				return false;
			}

			LToLongBiFuncMemento other = (LToLongBiFuncMemento) two;

			return LObjLongPair.argEquals(one.function, one.lastValue(), other.function, other.lastValue());
		});
	}
111235
public void elemSubtract(VTensor other) {
        checkEqualSize(this, other);
        for (int c = 0; c < this.size(); c++) {
            subtractValue(c, other.getValue(c));
        }
    }