object sep = AttrCollectionPop(kwargs, "sep", " ");

if (sep != null && !(sep is string)) {
    throw PythonOps.TypeError(
        "sep must be None or str, not {0}",
        PythonTypeOps.GetName(sep));
}

object end = AttrCollectionPop(kwargs, "end", "\n");

if (sep != null && !(sep is string)) { // Should be end, not sep
    throw PythonOps.TypeError(
        "end must be None or str, not {0}",
        PythonTypeOps.GetName(end));
}

var right = other as PredicateNullness;
if (other != null) // Should be "if (right != null)"
{
    if (this.value == right.value)
    {
        return this;
    }
}

public static int GetHashCode<T>(T[] a)
{
    if (a == null)
        return 0;
    const int prime = 31;
    int hash = 17;
    foreach (var item in a)
    {
        // item is T, and T may be a value type
        hash = hash * 23 + (item == null ? 0 : item.GetHashCode());
    }
    return hash;
}

internal override void write(byte[] foo, int s, int l) 
{
    .......
    int plen=(foo[s+6]&0xff)*256+(foo[s+7]&0xff);
    int dlen=(foo[s+8]&0xff)*256+(foo[s+9]&0xff);
    .......
}

public static Boolean operator ==(ComplexNumber c1, ComplexNumber c2)
{
    bool bEqual = false;
    if ((c1._realPart == c2._realPart) &&
            (c1._imaginaryPart == c2._imaginaryPart))
        bEqual = true;
    return bEqual;
}

public partial class AddAccountWizardForm : Form
{
    ...
    private Step m_CurrStep = Step.Screen1;
    ...
    private bool ValidateFields(Step m_CurrStep)
    {
        ...
    }
    ...
}

if (negx && negy) {
    return new BigInteger(-1, makeTwosComplement(zd));
} else if (negx || negy) {
    return new BigInteger(+1, zd);
} else {
    return new BigInteger(+1, zd);
}

public static object GetCharArrayValue(_Array arr) {
    return arr.NativeType.GetValue(arr._memHolder, arr, 0, false);
}
public static object GetWCharArrayValue(_Array arr) {
    return arr.NativeType.GetValue(arr._memHolder, arr, 0, false);
}

public enum TraceEventKind {
    FrameEnter,
    FrameExit,
    ThreadExit,
    TracePoint,
    Exception,
    ExceptionUnwind
}
....
Debugging.TraceEventKind kind = ...
....
switch (kind) {
    case Debugging.TraceEventKind.FrameEnter: traceEvent = "call"; break;
    case Debugging.TraceEventKind.TracePoint: traceEvent = "line"; break;
    case Debugging.TraceEventKind.Exception:
        traceEvent = "exception";
        object pyException = PythonExceptions.ToPython((Exception)payload);
        object pyType = ((IPythonObject)pyException).PythonType;
        args = PythonTuple.MakeTuple(pyType, pyException, null);
        break;
    case Debugging.TraceEventKind.FrameExit:
        traceEvent = "return";
        args = payload;
        break;
}

public static readonly WeakReference WeakMissingConstant = new WeakReference(
    StrongMissingConstant);
private static readonly object StrongMissingConstant = new object();

public struct Polynomial<Variable, Expression>
{
    ...
}
...
Polynomial<BoxedVariable<Variable>, BoxedExpression> pol;
...
Contract.Assume(!object.ReferenceEquals(pol, null));

for (int i = start; i > stop; i += step) {
    pa._data.Append(_data.GetData(i));
}

for (int j = 0; j < n; i++) {
    Cache.Integers[n - j - 1] = Reader.ReadInt32();
}

if (Math.Abs(InitialAngle - LastAngle) > 6.28318531) {
    ...
}

try
{
    mxRecords = GetMxRecords(domain);
}
catch
{
    new Exception("Can't connect to DNS server.");
}

class DictThreadGlobalState {
    public int DoneCount;
    public List<Thread> Threads = new List<Thread>();
    ...
}
...
while (globalState.DoneCount != globalState.Threads.Count) {
    // wait for threads to get back to start point
}

if (dt.TryLookupSlot(context, name, out slot)) {
    if (!hasValue || slot.IsSetDescriptor(context, this)) {
        if (slot.TryGetValue(context, instance, this, out newValue))
            value = newValue;
            return true;
    }
}

public sealed class Profiler {
    private static int _Index;
    private readonly Dictionary<string, int> _counters;
    public int GetTickIndex(string name) {
        lock (_counters) {
            if (!_counters.TryGetValue(name, out index)) {
                index = _Index++;
                _counters.Add(name, index);
            }
            ...
        }
        ...
    }
    ...
}

try {
    ...
} catch (Exception e) {
    e.ToString();
    errors = true;
    throw;
}

decimal a, b, r;
int n = x.Count();
...
a = (1 / n) * sY - b * (1 / n) * sX;

internal virtual long BaseRamBytesUsed()
{
    return RamUsageEstimator.NUM_BYTES_OBJECT_HEADER +
           2 * RamUsageEstimator.NUM_BYTES_OBJECT_REF +
           2 * RamUsageEstimator.NUM_BYTES_INT +
           2 * RamUsageEstimator.NUM_BYTES_INT +
           RamUsageEstimator.NUM_BYTES_FLOAT +
           RamUsageEstimator.NUM_BYTES_LONG;
}

public static MemoryStream SerializeToStream(object o)
{
    using (var stream = new MemoryStream())
    {
        Formatter.Serialize(stream, o);
        return stream;
    }
}

if (!BinaryUpdates.TryGetValue(update.Field, out fieldUpdates)) ;
{
    fieldUpdates = new HashMap<Term, BinaryDocValuesUpdate>();
    BinaryUpdates[update.Field] = fieldUpdates;
    BytesUsed.AddAndGet(BYTES_PER_BINARY_FIELD_ENTRY);
}

var pluginStates = string.Format(
    "plugin states: ({0} in total)", this.otherStates.Length);
if (this.otherStates.Length > 0)
{
    foreach (var state in this.otherStates)
    {
        var str = state.ToString();
        pluginStates += Environment.NewLine + str;
    }
}

public override string ToString()
{
    return String.Format(
        "Preconditions:\n{0}\nPostconditions:\n{1}\nObjectInvariants:\n{2}\n"
        "EntryAssumes:{3}\nCalleeAssumes:{4}MayReturnNull{5}",
      JoinWithDefaultIfNull("\n", this.PreConditions),
      JoinWithDefaultIfNull("\n", this.PostConditions),
      JoinWithDefaultIfNull("\n", this.ObjectInvariants),
      JoinWithDefaultIfNull("\n", this.NonNullFields),
      JoinWithDefaultIfNull("\n", this.EntryAssumes),
      JoinWithDefaultIfNull("\n", this.CalleeAssumes),
      this.MayReturnNull);
}

public class RequestWindowChange : Request
{
    public void setSize(int row, int col, int wp, int hp)
    {
        ...
    }
}

public void setPtySize(int col, int row, int wp, int hp)
{
    try
    {
        RequestWindowChange request=new RequestWindowChange();
        request.setSize(col, row, wp, hp);
        request.request(session, this);
    }
    catch(Exception e)
    {
        throw new JSchException("ChannelShell.setPtySize: "+e.ToString());
    }
}

[Обнаружено в ThreadStatic]
public static List<object> _trace = new List<object>();

[Обнаружено в ThreadStatic]
private bool _traceListenerSuspended;

public InvariantSubroutine(
    MethodCache<
        Local, Parameter, Type, Method, Field, Property,
        Event, Attribute, Assembly> methodCache,
    Subroutine inherited, Type associatedType)
    : base(methodCache)
{
    Contract.Requires(methodCache != null);
    this.AddSuccessor(this.Entry, "entry", this.Exit);
    this.AddBaseInvariant(this.Entry, this.Exit, inherited);
    this.Commit();
}

if (format <= Lucene3xSegmentInfoFormat.FORMAT_HAS_VECTORS)
{
    int hasVectors = input.ReadByte();
}

public static Automaton Union(Automaton a1, Automaton a2)
{
    if ((a1.IsSingleton && a2.IsSingleton && a1.singleton.Equals(a2.singleton)) || a1 == a2)
    {
        return a1.CloneIfRequired();
    }
    if (a1 == a2)
    {
        a1 = a1.CloneExpanded();
        a2 = a2.CloneExpanded();
    }
    ...
}

int newSize = Size + otherUpdates.Size;
if (newSize > int.MaxValue)
{
    throw new InvalidOperationException(
        "cannot support more than Integer.MAX_VALUE doc/value entries; size=" +
        Size + " other.size=" + otherUpdates.Size);
}

static void AreEqual<T>(T expected, T actual) {
    if (expected == null && actual == null) return;

    if (!expected.Equals(actual)) {
        Console.WriteLine("Expected: {0} Got: {1} from {2}",
            expected, actual, new StackTrace(true));
        throw new Exception();
    }
}

IAssemblyReference ar = null;
try {
    var tree2 = transformer.Visit(compilationUnitDeclaration);
    ar = tree2 as IAssemblyReference;
} catch (ConverterException e) {
    exceptionMessage = e.Message;
}
if (exceptionMessage != null) {
    yield return Tuple.Create(
        exceptionMessage, compilationUnitDeclaration.GetFirstToken().Span);
    yield break;
}
var unit = ar;
this.host.RegisterUnit(unit.ResolvedUnit);

public SubList(IList<T> list, int fromIndex, int toIndex)
{
    if (fromIndex < 0)
        throw new ArgumentOutOfRangeException("fromIndex");
    if (toIndex > list.Count)
        throw new ArgumentOutOfRangeException("toIndex");
    if (toIndex < fromIndex)
        throw new ArgumentOutOfRangeException("toIndex");
    if (list == null)
        throw new ArgumentNullException("list");
    this.list = list;
    this.fromIndex = fromIndex;
    this.toIndex = toIndex;
}

void Foo() {
    lock(a)
        lock(b)
            Baz1();
}

void Bar() {
    lock(b)
        lock(a)
            Baz2();
}

if (!(task.Result is ResultResponse) &&
    !(((ResultResponse)task.Result).Output is OutputRows))
{
    throw new DriverInternalError("Expected rows " + task.Result);
}

public static byte[] Compress(
    byte[] value, int offset, int length, int compressionLevel)
{
    var bos = new ByteArrayOutputStream(length);
    Deflater compressor = SharpZipLib.CreateDeflater();
    try
    {
        compressor.SetLevel(compressionLevel);
        compressor.SetInput(value, offset, length);
        compressor.Finish();
        var buf = new byte[1024];
        while (!compressor.IsFinished)
        {
            int count = compressor.Deflate(buf);
            bos.Write(buf, 0, count);
        }
    }
    finally
    {
    }
    return bos.ToArray();
}

var file = new StreamWriter(Path.Combine(cwd, writeBatchFile + ".bat"));
file.WriteLine("\"{0}\" {1} %1 %2 %3 %4 %5", i.FileName, i.Arguments);
file.Close();