which is quite hard anyway ...
182977
public IScope createFeatureCallSerializationScope(EObject context) {
		if (!(context instanceof XAbstractFeatureCall)) {
			return IScope.NULLSCOPE;
		}
		XAbstractFeatureCall call = (XAbstractFeatureCall) context;
		JvmIdentifiableElement feature = call.getFeature();
		// this and super - logical container aware FeatureScopes
		if (feature instanceof JvmType) {
			return getTypeScope(call, (JvmType) feature);
		}
		if (feature instanceof JvmConstructor) {
			return getThisOrSuperScope(call, (JvmConstructor) feature);
		}
		if (feature instanceof JvmExecutable) {
			return getExecutableScope(call, feature);
		}
		if (feature instanceof JvmFormalParameter || feature instanceof JvmField || feature instanceof XVariableDeclaration || feature instanceof XSwitchExpression) {
			return new SingletonScope(EObjectDescription.create(feature.getSimpleName(), feature), IScope.NULLSCOPE);
		}
		return IScope.NULLSCOPE;
	}
1334184
private void tryReconcile() {
    if (!this.reconciliationLock.tryLock()) {
      return;
    }

    try {
      reconcile();

      // Keep on warning after every reconcile if nonContiguousMsgIds reaches 500 (kept it a bit higher so that we won't get unnecessary warning due to high concurrency).
      if (nonContiguousMsgIds.size() > 500) {
        LOGGER.warn("Non - Contiguous Message ID has size : {}, with highestContiguousMsgId as : {}", nonContiguousMsgIds.size(), highestContiguousMsgId);
      }
    } finally {
      this.reconciliationLock.unlock();
    }
  }
616003
def challenge(self):
        
        response = super(ConfigBasicAuth, self).challenge()
        raise with_headers(Unauthorized(), response.headers)
821701
def push(h, x):
    """"""
    h.push(x)
    up(h, h.size()-1)
1161494
private void climb(long key, @Nullable QueueType queue, boolean isFull) {
    if (queue == null) {
      climber.onMiss(key, isFull);
    } else {
      climber.onHit(key, queue, isFull);
    }

    double probationSize = maximumSize - windowSize - protectedSize;
    Adaptation adaptation = climber.adapt(windowSize, probationSize, protectedSize, isFull);
    if (adaptation.type == INCREASE_WINDOW) {
      increaseWindow(adaptation.amount);
    } else if (adaptation.type == DECREASE_WINDOW) {
      decreaseWindow(adaptation.amount);
    }
  }
1224782
function (a, b) {
    var aNeedsB = false;
    var bNeedsA = false;

    aNeedsB = Object.
    keys(a.dependencies).
    some(function (dependency) {
        return dependency === b.name;
    });

    if (aNeedsB) {
        return 1;
    }

    bNeedsA = Object.
    keys(b.dependencies).
    some(function (dependency) {
        return dependency === a.name;
    });

    if (bNeedsA) {
        return -1;
    }

    return 0;
}
1147512
function() {
		//Pluralizes the first part in "<x> of <y>"
		var bundle = this.match(/(\w+)\sof\s\w+/);
		if (bundle) return this.replace(bundle[1], bundle[1].getPlural());
		str = this.replace(/([^aeiou])y$/, '$1ies');
		if (str==this) str = str.replace(/([ch|sh|x|s|o])$/, '$1es');
		if (str==this) str += 's';
		return str;
	}
842986
function tryRequire(name, def, isRoot) {
    function _require() {
        if (!is_1.isNode())
            /* istanbul ignore next */
            return to_1.toDefault(null, def);
        if (isRoot)
            return require.main.require(name);
        return require(name);
    }
    return tryWrap(_require)(def);
}
682755
def __set_hard_hard_constraints(self, tdata1, tdata2, seeds):
        
        seeds_mask = (seeds == 1) | (seeds == 3)
        tdata2[seeds_mask] = np.max(tdata2) + 1
        tdata1[seeds_mask] = 0

        seeds_mask = (seeds == 2) | (seeds == 4)
        tdata1[seeds_mask] = np.max(tdata1) + 1
        tdata2[seeds_mask] = 0

        return tdata1, tdata2
1175711
def reshard(args):
    
    cluster = Cluster.from_node(ClusterNode.from_uri(args.cluster))
    cluster.reshard()
585804
private void mmuli(int n, double[] A, double[] B, double[] C) {
        for (int i = 0; i < n * n; i++) {
            C[i] = 0;
        }

        for (int j = 0; j < n; j++) {
            int jn = j * n;
            for (int k = 0; k < n; k++) {
                int kn = k * n;
                double bkjn = B[k + jn];
                for (int i = 0; i < n; i++) {
                    C[i + jn] += A[i + kn] * bkjn;
                }
            }
        }
    }
600909
@Override
    public void hard(String format, Object... args) {
        rawout(prefix(format), args);
    }
1338006
def challenge():
  """"""
  enums = dict(
    ACTIVE="active",
    UPCOMING="upcoming",
    HIRING="hiring",
    ALL="all",
    SHORT="short",
  )

  return type('Enum', (), enums)
976707
private final void push() {
    if (ptr >= stack.length) {
      // doubling here is probably overkill, but anything that needs to double more than
      // once (32 levels deep) is very atypical anyway.
      byte[] newstack = new byte[stack.length<<1];
      System.arraycopy(stack,0,newstack,0,stack.length);
      stack = newstack;
    }
    stack[ptr++] = state;
  }
847875
def otherwise(first, second)
      first = first.to_s
      first.empty? ? second : first
    end
107291
private int computeDifficulty(Operation left)
    {
        int difficulty = 0;
        if (left instanceof MappedOperation)
        {
            difficulty = 10*getMappingDepth(left);
        }
        return difficulty;
    }
162887
def TakeWhile(self: dict, f):
    
    if is_to_destruct(f):
        f = destruct_func(f)

    for e in self.items():
        if not f(e):
            break
        yield e