Does t have the same bounds for quantified variables as s?
559902
public boolean hasSameBounds(ForAll t, ForAll s) {
        List<Type> l1 = t.tvars;
        List<Type> l2 = s.tvars;
        while (l1.nonEmpty() && l2.nonEmpty() &&
               isSameType(l1.head.getUpperBound(),
                          subst(l2.head.getUpperBound(),
                                s.tvars,
                                t.tvars))) {
            l1 = l1.tail;
            l2 = l2.tail;
        }
        return l1.isEmpty() && l2.isEmpty();
    }
810302
private static int compareMagnitudeNormalized(long xs, int xscale, BigInteger ys, int yscale) {
        // assert "ys can't be represented as long"
        if (xs == 0)
            return -1;
        int sdiff = xscale - yscale;
        if (sdiff < 0) {
            if (longMultiplyPowerTen(xs, -sdiff) == INFLATED ) {
                return bigMultiplyPowerTen(xs, -sdiff).compareMagnitude(ys);
            }
        }
        return -1;
    }
286905
public static void v(String s, Throwable t) {
		log(Level.FINEST, s, t);
	}
1113107
def bounds(self) -> typing.Tuple[typing.Tuple[float, float], typing.Tuple[float, float]]:
        """"""
        ...
986741
private static int getJPEGQuality(final int[][] quantizationTables) throws IOException {
//        System.err.println("tables: " + Arrays.deepToString(tables));

        // TODO: Determine lossless JPEG, it's an entirely different algorithm

        int qvalue;
        
        // Determine the JPEG compression quality from the quantization tables.
        int sum = 0;
        for (int i = 0; i < NUM_QUANT_TABLES; i++) {
            if (quantizationTables[i] != null) {
                for (int j = 0; j < DCT_SIZE_2; j++) {
                    sum += quantizationTables[i][j];
                }
            }
        }

        int[] hash, sums;

        if (quantizationTables[0] != null && quantizationTables[1] != null) {
            // TODO: Make constant
            hash = new int[] {
                    1020, 1015, 932, 848, 780, 735, 702, 679, 660, 645,
                    632, 623, 613, 607, 600, 594, 589, 585, 581, 571,
                    555, 542, 529, 514, 494, 474, 457, 439, 424, 410,
                    397, 386, 373, 364, 351, 341, 334, 324, 317, 309,
                    299, 294, 287, 279, 274, 267, 262, 257, 251, 247,
                    243, 237, 232, 227, 222, 217, 213, 207, 202, 198,
                    192, 188, 183, 177, 173, 168, 163, 157, 153, 148,
                    143, 139, 132, 128, 125, 119, 115, 108, 104, 99,
                    94, 90, 84, 79, 74, 70, 64, 59, 55, 49,
                    45, 40, 34, 30, 25, 20, 15, 11, 6, 4,
                    0
            };
            sums = new int[] {
                    32640, 32635, 32266, 31495, 30665, 29804, 29146, 28599, 28104,
                    27670, 27225, 26725, 26210, 25716, 25240, 24789, 24373, 23946,
                    23572, 22846, 21801, 20842, 19949, 19121, 18386, 17651, 16998,
                    16349, 15800, 15247, 14783, 14321, 13859, 13535, 13081, 12702,
                    12423, 12056, 11779, 11513, 11135, 10955, 10676, 10392, 10208,
                    9928, 9747, 9564, 9369, 9193, 9017, 8822, 8639, 8458,
                    8270, 8084, 7896, 7710, 7527, 7347, 7156, 6977, 6788,
                    6607, 6422, 6236, 6054, 5867, 5684, 5495, 5305, 5128,
                    4945, 4751, 4638, 4442, 4248, 4065, 3888, 3698, 3509,
                    3326, 3139, 2957, 2775, 2586, 2405, 2216, 2037, 1846,
                    1666, 1483, 1297, 1109, 927, 735, 554, 375, 201,
                    128, 0
            };

            qvalue = quantizationTables[0][2] + quantizationTables[0][53] + quantizationTables[1][0] + quantizationTables[1][DCT_SIZE_2 - 1];
        }
        else if (quantizationTables[0] != null) {
            // TODO: Make constant
            hash = new int[] {
                    510, 505, 422, 380, 355, 338, 326, 318, 311, 305,
                    300, 297, 293, 291, 288, 286, 284, 283, 281, 280,
                    279, 278, 277, 273, 262, 251, 243, 233, 225, 218,
                    211, 205, 198, 193, 186, 181, 177, 172, 168, 164,
                    158, 156, 152, 148, 145, 142, 139, 136, 133, 131,
                    129, 126, 123, 120, 118, 115, 113, 110, 107, 105,
                    102, 100, 97, 94, 92, 89, 87, 83, 81, 79,
                    76, 74, 70, 68, 66, 63, 61, 57, 55, 52,
                    50, 48, 44, 42, 39, 37, 34, 31, 29, 26,
                    24, 21, 18, 16, 13, 11, 8, 6, 3, 2,
                    0
            };
            sums = new int[] {
                    16320, 16315, 15946, 15277, 14655, 14073, 13623, 13230, 12859,
                    12560, 12240, 11861, 11456, 11081, 10714, 10360, 10027, 9679,
                    9368, 9056, 8680, 8331, 7995, 7668, 7376, 7084, 6823,
                    6562, 6345, 6125, 5939, 5756, 5571, 5421, 5240, 5086,
                    4976, 4829, 4719, 4616, 4463, 4393, 4280, 4166, 4092,
                    3980, 3909, 3835, 3755, 3688, 3621, 3541, 3467, 3396,
                    3323, 3247, 3170, 3096, 3021, 2952, 2874, 2804, 2727,
                    2657, 2583, 2509, 2437, 2362, 2290, 2211, 2136, 2068,
                    1996, 1915, 1858, 1773, 1692, 1620, 1552, 1477, 1398,
                    1326, 1251, 1179, 1109, 1031, 961, 884, 814, 736,
                    667, 592, 518, 441, 369, 292, 221, 151, 86,
                    64, 0
            };

            qvalue = quantizationTables[0][2] + quantizationTables[0][53];
        }
        else {
            return -1;
        }

        for (int i = 0; i < 100; i++) {
            if (qvalue < hash[i] && sum < sums[i]) {
                continue;
            }

            if (qvalue <= hash[i] && sum <= sums[i] || i >= 50) {
                return i + 1;
            }

            break;
        }

        return -1;
    }
200403
def has_bounds(self):
        """"""
        bounds = self.bounds
        if bounds in (None, [None, None]):
            return False
        for ib, bound in enumerate(bounds):
            if bound is not None:
                sign_ = 2 * ib - 1
                for bound_i in bound:
                    if bound_i is not None and sign_ * bound_i < np.inf:
                        return True
        return False
794046
function _shallowEqual(lhs, rhs) {
    var lhsKeys = Object.keys(lhs);
    var rhsKeys = Object.keys(rhs);
    if (lhsKeys.length !== rhsKeys.length) {
      return false;
    }
    for (var k in lhs) {
      if (lhs[k] !== rhs[k]) {
        return false;
      }
    }
    return true;
  }
1361223
def proveGt(x,tTilde,kw,y):
    
    # Verify types
    assertType(x, G1Element)
    assertType(tTilde, G2Element)

    # Compute the proof.
    beta = pair(x,tTilde)
    g = generatorGt()
    p = g**kw
    v = randomZ(orderGt())
    t1 = g**v
    t2 = beta**v

    c = hashZ(g,p,beta,y,t1,t2)
    u = (v- (c*kw)) % orderGt()
    return (p,c,u)
989168
def UGE(a: BitVec, b: BitVec) -> Bool:
    
    return Or(UGT(a, b), a == b)
204936
function _compareRDFTriples(t1, t2) {
  var attrs = ['subject', 'predicate', 'object'];
  for(var i = 0; i < attrs.length; ++i) {
    var attr = attrs[i];
    if(t1[attr].type !== t2[attr].type || t1[attr].value !== t2[attr].value) {
      return false;
    }
  }
  if(t1.object.language !== t2.object.language) {
    return false;
  }
  if(t1.object.datatype !== t2.object.datatype) {
    return false;
  }
  return true;
}
557317
def p_stmt_cmp_eq(p):
    """"""
    p[0] = ast.EqNode(ast.VariableNode(p[1]), ast.CmpExprNode(p[4], p[3], p[5]))
398912
def val_to_bin_bounded(edges, x):
    """"""
    nbins = len(edges) - 1
    ibin = val_to_bin(edges, x)
    ibin[ibin < 0] = 0
    ibin[ibin > nbins - 1] = nbins - 1
    return ibin
1009588
private void dfs(int v, int[] cc, int id) {
        cc[v] = id;
        for (int t = 0; t < n; t++) {
            if (graph[v][t] != 0.0) {
                if (cc[t] == -1) {
                    dfs(t, cc, id);
                }
            }
        }
    }
978225
public void freeVariables(SyntacticItem e, Set<WyalFile.VariableDeclaration> freeVars) {
		if (e instanceof Expr.VariableAccess) {
			Expr.VariableAccess va = (Expr.VariableAccess) e;
			freeVars.add(va.getVariableDeclaration());
		} else if (e instanceof Expr.Quantifier) {
			Expr.Quantifier q = (Expr.Quantifier) e;
			freeVariables(q.getBody(), freeVars);
			// Remove any bound variables
			for (WyalFile.VariableDeclaration vd : q.getParameters()) {
				freeVars.remove(vd);
			}
		} else {
			for (int i = 0; i != e.size(); ++i) {
				SyntacticItem item = e.get(i);
				if (item != null) {
					freeVariables(item, freeVars);
				}
			}
		}
	}
1229353
public boolean containedBy(Type t, Type s) {
        switch (t.getTag()) {
        case UNDETVAR:
            if (s.hasTag(WILDCARD)) {
                UndetVar undetvar = (UndetVar)t;
                WildcardType wt = (WildcardType)s;
                switch(wt.kind) {
                    case UNBOUND:
                        break;
                    case EXTENDS: {
                        Type bound = wildUpperBound(s);
                        undetvar.addBound(InferenceBound.UPPER, bound, this);
                        break;
                    }
                    case SUPER: {
                        Type bound = wildLowerBound(s);
                        undetvar.addBound(InferenceBound.LOWER, bound, this);
                        break;
                    }
                }
                return true;
            } else {
                return isSameType(t, s);
            }
        case ERROR:
            return true;
        default:
            return containsType(s, t);
        }
    }
676385
def estimateHeritabilities(self, K, verbose=False):
        
        
        # Fit single trait model
        varg  = SP.zeros(self.P)
        varn  = SP.zeros(self.P)
        fixed = SP.zeros((1,self.P))
        
        for p in range(self.P):
            y = self.Y[:,p:p+1]
            lmm = limix.CLMM()
            lmm.setK(K)
            lmm.setSNPs(SP.ones((K.shape[0],1)))
            lmm.setPheno(y)
            lmm.setCovs(SP.zeros((K.shape[0],1)))
            lmm.setVarcompApprox0(-20, 20, 1000)
            lmm.process()
            delta = SP.exp(lmm.getLdelta0()[0,0])
            Vtot  = SP.exp(lmm.getLSigma()[0,0])
    
            varg[p] = Vtot
            varn[p] = delta*Vtot
            fixed[:,p] = lmm.getBetaSNP()
    
            if verbose: print(p)
    
        sth = {}
        sth['varg']  = varg
        sth['varn']  = varn
        sth['fixed'] = fixed

        return sth
1299128
function quantified(rule, min, max) {
        if (min === void 0) { min = 0; }
        if (max === void 0) { max = Infinity; }
        if (min === 0 && max === 1)
            return new Optional(RuleTypeToRule(rule));
        else
            return new Quantified(RuleTypeToRule(rule), min, max);
    }