text:
``` diff
 namespace System {
     public class AggregateException : Exception {
+        public override string Message { get; }
     }
-    public sealed class AppDomain : MarshalByRefObject {
+    public class AppDomain : MarshalByRefObject {
-        public new Type GetType();

-        public override object InitializeLifetimeService();

     }
+    public sealed class ApplicationIdentity : ISerializable {
+        public ApplicationIdentity(string applicationIdentityFullName);
+        public string CodeBase { get; }
+        public string FullName { get; }
+        void System.Runtime.Serialization.ISerializable.GetObjectData(SerializationInfo info, StreamingContext context);
+        public override string ToString();
+    }
     public abstract class Array : ICloneable, ICollection, IEnumerable, IList, IStructuralComparable, IStructuralEquatable {
+        public static void Fill<T>(T[] array, T value);
+        public static void Fill<T>(T[] array, T value, int startIndex, int count);
+        public static void Reverse<T>(T[] array);
+        public static void Reverse<T>(T[] array, int index, int length);
     }
     [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
     public struct ArraySegment<T> : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+        public static ArraySegment<T> Empty { get; }
+        public T this[int index] { get; set; }
+        public void CopyTo(ArraySegment<T> destination);
+        public void CopyTo(T[] destination);
+        public void CopyTo(T[] destination, int destinationIndex);
+        public ArraySegment<T>.Enumerator GetEnumerator();
+        public static implicit operator ArraySegment<T> (T[] array);
+        public ArraySegment<T> Slice(int index);
+        public ArraySegment<T> Slice(int index, int count);
+        public T[] ToArray();
+        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
+            public T Current { get; }
+            object System.Collections.IEnumerator.Current { get; }
+            public void Dispose();
+            public bool MoveNext();
+            void System.Collections.IEnumerator.Reset();
+        }
     }
     public static class BitConverter {
+        public static float Int32BitsToSingle(int value);
+        public static int SingleToInt32Bits(float value);
     }
     [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
     public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, ISerializable {
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
     }
-    public class DuplicateWaitObjectException : ArgumentException
+    public class DuplicateWaitObjectException : ArgumentException, ISerializable
     public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable {
+        public static TEnum Parse<TEnum>(string value) where TEnum : struct;
+        public static TEnum Parse<TEnum>(string value, bool ignoreCase) where TEnum : struct;
+        TypeCode System.IConvertible.GetTypeCode();
+        public static bool TryParse(Type enumType, string value, bool ignoreCase, out object result);
+        public static bool TryParse(Type enumType, string value, out object result);
     }
     public static class GC {
+        public static long GetAllocatedBytesForCurrentThread();
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct IntPtr : ISerializable {
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct IntPtr : IEquatable<IntPtr>, ISerializable {
+        bool System.IEquatable<System.IntPtr>.Equals(IntPtr other);
     }
     public class Lazy<T> {
+        public Lazy(T value);
     }
     public sealed class LocalDataStoreSlot {
+        ~LocalDataStoreSlot();
     }
     public static class Math {
+        public static byte Clamp(byte value, byte min, byte max);
+        public static decimal Clamp(decimal value, decimal min, decimal max);
+        public static double Clamp(double value, double min, double max);
+        public static short Clamp(short value, short min, short max);
+        public static int Clamp(int value, int min, int max);
+        public static long Clamp(long value, long min, long max);
+        public static sbyte Clamp(sbyte value, sbyte min, sbyte max);
+        public static float Clamp(float value, float min, float max);
+        public static ushort Clamp(ushort value, ushort min, ushort max);
+        public static uint Clamp(uint value, uint min, uint max);
+        public static ulong Clamp(ulong value, ulong min, ulong max);
     }
+    public static class MathF {
+        public const float E = 2.71828175f;
+        public const float PI = 3.14159274f;
+        public static float Abs(float x);
+        public static float Acos(float x);
+        public static float Asin(float x);
+        public static float Atan(float x);
+        public static float Atan2(float y, float x);
+        public static float Ceiling(float x);
+        public static float Cos(float x);
+        public static float Cosh(float x);
+        public static float Exp(float x);
+        public static float Floor(float x);
+        public static float IEEERemainder(float x, float y);
+        public static float Log(float x);
+        public static float Log(float x, float y);
+        public static float Log10(float x);
+        public static float Max(float x, float y);
+        public static float Min(float x, float y);
+        public static float Pow(float x, float y);
+        public static float Round(float x);
+        public static float Round(float x, int digits);
+        public static float Round(float x, int digits, MidpointRounding mode);
+        public static float Round(float x, MidpointRounding mode);
+        public static int Sign(float x);
+        public static float Sin(float x);
+        public static float Sinh(float x);
+        public static float Sqrt(float x);
+        public static float Tan(float x);
+        public static float Tanh(float x);
+        public static float Truncate(float x);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct ReadOnlySpan<T> {
+        public unsafe ReadOnlySpan(void* pointer, int length);
+        public ReadOnlySpan(T[] array);
+        public ReadOnlySpan(T[] array, int start);
+        public ReadOnlySpan(T[] array, int start, int length);
+        public static ReadOnlySpan<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public int Length { get; }
+        public T this[int index] { get; }
+        public void CopyTo(Span<T> destination);
+        public static ReadOnlySpan<T> DangerousCreate(object obj, ref T objectData, int length);
+        public ref T DangerousGetPinnableReference();
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right);
+        public static implicit operator ReadOnlySpan<T> (ArraySegment<T> arraySegment);
+        public static implicit operator ReadOnlySpan<T> (T[] array);
+        public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right);
+        public ReadOnlySpan<T> Slice(int start);
+        public ReadOnlySpan<T> Slice(int start, int length);
+        public T[] ToArray();
+        public bool TryCopyTo(Span<T> destination);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Span<T> {
+        public unsafe Span(void* pointer, int length);
+        public Span(T[] array);
+        public Span(T[] array, int start);
+        public Span(T[] array, int start, int length);
+        public static Span<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public int Length { get; }
+        public ref T this[int index] { get; }
+        public void Clear();
+        public void CopyTo(Span<T> destination);
+        public static Span<T> DangerousCreate(object obj, ref T objectData, int length);
+        public ref T DangerousGetPinnableReference();
+        public override bool Equals(object obj);
+        public void Fill(T value);
+        public override int GetHashCode();
+        public static bool operator ==(Span<T> left, Span<T> right);
+        public static implicit operator Span<T> (ArraySegment<T> arraySegment);
+        public static implicit operator ReadOnlySpan<T> (Span<T> span);
+        public static implicit operator Span<T> (T[] array);
+        public static bool operator !=(Span<T> left, Span<T> right);
+        public Span<T> Slice(int start);
+        public Span<T> Slice(int start, int length);
+        public T[] ToArray();
+        public bool TryCopyTo(Span<T> destination);
+    }
+    public static class SpanExtensions {
+        public static ReadOnlySpan<byte> AsBytes<T>(this ReadOnlySpan<T> source) where T : struct;
+        public static Span<byte> AsBytes<T>(this Span<T> source) where T : struct;
+        public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ArraySegment<T> arraySegment);
+        public static ReadOnlySpan<T> AsReadOnlySpan<T>(this T[] array);
+        public static ReadOnlySpan<char> AsSpan(this string text);
+        public static Span<T> AsSpan<T>(this ArraySegment<T> arraySegment);
+        public static Span<T> AsSpan<T>(this T[] array);
+        public static void CopyTo<T>(this T[] array, Span<T> destination);
+        public static int IndexOf(this ReadOnlySpan<byte> span, byte value);
+        public static int IndexOf(this ReadOnlySpan<byte> span, ReadOnlySpan<byte> value);
+        public static int IndexOf(this Span<byte> span, byte value);
+        public static int IndexOf(this Span<byte> span, ReadOnlySpan<byte> value);
+        public static int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T>;
+        public static int IndexOf<T>(this ReadOnlySpan<T> span, T value) where T : struct, IEquatable<T>;
+        public static int IndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T>;
+        public static int IndexOf<T>(this Span<T> span, T value) where T : struct, IEquatable<T>;
+        public static int IndexOfAny(this ReadOnlySpan<byte> span, byte value0, byte value1);
+        public static int IndexOfAny(this ReadOnlySpan<byte> span, byte value0, byte value1, byte value2);
+        public static int IndexOfAny(this ReadOnlySpan<byte> span, ReadOnlySpan<byte> values);
+        public static int IndexOfAny(this Span<byte> span, byte value0, byte value1);
+        public static int IndexOfAny(this Span<byte> span, byte value0, byte value1, byte value2);
+        public static int IndexOfAny(this Span<byte> span, ReadOnlySpan<byte> values);
+        public static ReadOnlySpan<TTo> NonPortableCast<TFrom, TTo>(this ReadOnlySpan<TFrom> source) where TFrom : struct where TTo : struct;
+        public static Span<TTo> NonPortableCast<TFrom, TTo>(this Span<TFrom> source) where TFrom : struct where TTo : struct;
+        public static bool SequenceEqual(this ReadOnlySpan<byte> first, ReadOnlySpan<byte> second);
+        public static bool SequenceEqual(this Span<byte> first, ReadOnlySpan<byte> second);
+        public static bool SequenceEqual<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second) where T : struct, IEquatable<T>;
+        public static bool SequenceEqual<T>(this Span<T> first, ReadOnlySpan<T> second) where T : struct, IEquatable<T>;
+        public static bool StartsWith(this ReadOnlySpan<byte> span, ReadOnlySpan<byte> value);
+        public static bool StartsWith(this Span<byte> span, ReadOnlySpan<byte> value);
+        public static bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T>;
+        public static bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : struct, IEquatable<T>;
+    }
     public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
+        public bool EndsWith(char value);
+        public int GetHashCode(StringComparison comparisonType);
+        public static String Join(char separator, params object[] values);
+        public static String Join(char separator, params string[] value);
+        public static String Join(char separator, string[] value, int startIndex, int count);
+        public static String Join<T>(char separator, IEnumerable<T> values);
+        public String Replace(String oldValue, String newValue, bool ignoreCase, CultureInfo culture);
+        public String Replace(String oldValue, String newValue, StringComparison comparisonType);
+        public string[] Split(char separator, int count, StringSplitOptions options=(StringSplitOptions)(0));
+        public string[] Split(char separator, StringSplitOptions options=(StringSplitOptions)(0));
+        public string[] Split(String separator, int count, StringSplitOptions options=(StringSplitOptions)(0));
+        public string[] Split(String separator, StringSplitOptions options=(StringSplitOptions)(0));
+        public bool StartsWith(char value);
+        public String Trim(char trimChar);
+        public String TrimEnd();
+        public String TrimEnd(char trimChar);
+        public String TrimStart();
+        public String TrimStart(char trimChar);
     }
     public abstract class StringComparer : IComparer, IComparer<string>, IEqualityComparer, IEqualityComparer<string> {
+        public static StringComparer FromComparison(StringComparison comparisonType);
+        bool System.Collections.IEqualityComparer.Equals(object x, object y);
+        int System.Collections.IEqualityComparer.GetHashCode(object obj);
     }
     [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
     public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable {
+        public TimeSpan Divide(double divisor);
+        public double Divide(TimeSpan ts);
+        public TimeSpan Multiply(double factor);
+        public static TimeSpan operator /(TimeSpan timeSpan, double divisor);
+        public static double operator /(TimeSpan t1, TimeSpan t2);
+        public static TimeSpan operator *(double factor, TimeSpan timeSpan);
+        public static TimeSpan operator *(TimeSpan timeSpan, double factor);
     }
-    public class Tuple<T1> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    public class Tuple<T1, T2> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1, T2> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    public class Tuple<T1, T2, T3> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1, T2, T3> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    public class Tuple<T1, T2, T3, T4> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1, T2, T3, T4> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    public class Tuple<T1, T2, T3, T4, T5> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1, T2, T3, T4, T5> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    public class Tuple<T1, T2, T3, T4, T5, T6> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1, T2, T3, T4, T5, T6> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IStructuralComparable, IStructuralEquatable {
+    public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
     public abstract class Type : MemberInfo, IReflect {
+        public virtual bool IsSZArray { get; }
+        public virtual bool IsTypeDefinition { get; }
+        public virtual bool IsVariableBoundArray { get; }
     }
-    public class TypeUnloadedException : SystemException
+    public class TypeUnloadedException : SystemException, ISerializable
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct UIntPtr : ISerializable {
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct UIntPtr : IEquatable<UIntPtr>, ISerializable {
+        bool System.IEquatable<System.UIntPtr>.Equals(UIntPtr other);
     }
+    public enum UriIdnScope {
+        All = 2,
+        AllExceptIntranet = 1,
+        None = 0,
+    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
-    public struct ValueTuple : IComparable, IComparable<ValueTuple>, IEquatable<ValueTuple>, IStructuralComparable, IStructuralEquatable {
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+    public struct ValueTuple : IComparable, IComparable<ValueTuple>, IEquatable<ValueTuple>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1> : IComparable, IComparable<ValueTuple<T1>>, IEquatable<ValueTuple<T1>>, IStructuralComparable, IStructuralEquatable {
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct ValueTuple<T1> : IComparable, IComparable<ValueTuple<T1>>, IEquatable<ValueTuple<T1>>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1, T2> : IComparable, IComparable<ValueTuple<T1, T2>>, IEquatable<ValueTuple<T1, T2>>, IStructuralComparable, IStructuralEquatable {
+    public struct ValueTuple<T1, T2> : IComparable, IComparable<ValueTuple<T1, T2>>, IEquatable<ValueTuple<T1, T2>>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1, T2, T3> : IComparable, IComparable<ValueTuple<T1, T2, T3>>, IEquatable<ValueTuple<T1, T2, T3>>, IStructuralComparable, IStructuralEquatable {
+    public struct ValueTuple<T1, T2, T3> : IComparable, IComparable<ValueTuple<T1, T2, T3>>, IEquatable<ValueTuple<T1, T2, T3>>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1, T2, T3, T4> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4>>, IEquatable<ValueTuple<T1, T2, T3, T4>>, IStructuralComparable, IStructuralEquatable {
+    public struct ValueTuple<T1, T2, T3, T4> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4>>, IEquatable<ValueTuple<T1, T2, T3, T4>>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1, T2, T3, T4, T5> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5>>, IStructuralComparable, IStructuralEquatable {
+    public struct ValueTuple<T1, T2, T3, T4, T5> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5>>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1, T2, T3, T4, T5, T6> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IStructuralComparable, IStructuralEquatable {
+    public struct ValueTuple<T1, T2, T3, T4, T5, T6> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6>>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IStructuralComparable, IStructuralEquatable {
+    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7>>, IStructuralComparable, IStructuralEquatable, ITuple {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IStructuralComparable, IStructuralEquatable where TRest : struct {
+    public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IStructuralComparable, IStructuralEquatable, ITuple where TRest : struct {
+        object System.Runtime.CompilerServices.ITuple.this[int index] { get; }
+        int System.Runtime.CompilerServices.ITuple.Length { get; }
     }
     public sealed class WeakReference<T> : ISerializable where T : class {
+        ~WeakReference();
     }
 }
```


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Quail {% block title %}{% endblock title %}</title>

    <link href="../../static/bootstrap/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" type="text/css" href="../../static/css/quail-base.css">

        <form method="get">

              {% if request.args.has_key("query") %}
                <input type="text" class="form-control" name="query" placeholder="Type a query..." value="{{ request.args.get("query") }}">
              {% else %}
                <input type="text" class="form-control" name="query" placeholder="Type a query...">
              {% endif %}

                <input type="submit" class="btn btn-default" value="Go"/>

        </form>

      {% block contents %}{% endblock contents %}

    {% block scripts %}{% endblock scripts %}

redpajama_set_name: RedPajamaGithub


text:
package org.PrimeSoft.MCPainter.Drawing.Blocks;

import java.util.HashMap;
import java.util.Map;
import org.PrimeSoft.MCPainter.Texture.TextureManager;
import org.PrimeSoft.MCPainter.Texture.VanillaTextureProvider;
import org.bukkit.Material;

/**
 *
 * @author SBPrime
 */
public class VanillaBlockProvider implements IBlockProvider {

    private final VanillaTextureProvider m_tex;
    private final Map<Integer, IDrawableElement> m_blockFaces;

    @Override
    public int getBlocksCount() {
        return m_blockFaces.size();
    }

    public VanillaBlockProvider(TextureManager textureManager) {
        if (textureManager == null) {
            m_tex = null;
            m_blockFaces = null;
            return;
        }

        m_tex = textureManager.getVanilla();
        m_blockFaces = new HashMap<Integer, IDrawableElement>();
        m_blockFaces.put(0x1d, new Piston(m_tex, true)); //1d - Sticky piston
        m_blockFaces.put(0x21, new Piston(m_tex, false)); //21 - Piston
        m_blockFaces.put(0x22, new PistonExtension(m_tex)); //22 - Piston extended
        m_blockFaces.put(0x63, new Shroom(m_tex, 3)); //63 - Huge brow mushroom
        m_blockFaces.put(0x64, new Shroom(m_tex, 2)); //64 - Huge red mushroom
    }

    @Override
    public IDrawableElement getBlock(String name) {
        Material blockMaterial = Material.getMaterial(name.toUpperCase());
        if (blockMaterial == null) {
            return null;
        }

        int materialId = blockMaterial.getId();
        return getBlock(materialId);
    }

    @Override
    public IDrawableElement getBlock(int materialId) {
        if (m_blockFaces.containsKey(materialId))
        {
            return m_blockFaces.get(materialId);
        }

        return null;
    }
}


text:
package com.hdcookbook.grin;

import com.hdcookbook.grin.commands.Command;
import com.hdcookbook.grin.util.Debug;

import com.hdcookbook.grin.io.ShowBuilder;
import com.hdcookbook.grin.io.binary.GrinDataOutputStream;
import java.io.IOException;
import java.util.ArrayList;

/**
 * Represents an individual command that is defined in-line in a show file.
 * An SEShowCommand participates in generating the Xlet subclass of Command
 * for a show.  It also runs something reasonable in SE emulation mode.
 *
 * @see SEShowCommands
 *
 *  @author     Bill Foote (http://jovial.com)
 **/
public class SEShowCommand extends Command implements SENode {

    private SEShowCommands container;
    int commandNumber;
    private String originalSource;
    private String grinviewMethodBody;
    private String xletMethodBody;
    private ArrayList<Command> subCommands = new ArrayList<Command>();
    private GrinXHelper seCommand = null;
    private boolean triedSeCommand = false;

    SEShowCommand(SEShow show, SEShowCommands container, int commandNumber) {
        super(show);
        this.container = container;
        this.commandNumber = commandNumber;
    }

    /**
     * Adds a sub-command to this command object.  To execute it, run
     * the java expression
     * "runSubCommand(number);"
     *
     * @param cmd   The command to add
     * @return The java source code to invoke this command in the xlet or in
     *              griview.
     */
    public String addSubCommand(Command cmd) {
        int num = subCommands.size();
        subCommands.add(cmd);
        return "runSubCommand(" + num + ", grinCaller);";
    }

    public int getCommandNumber() {
        return commandNumber;
    }

    public Command[] getSubCommands() {
        return subCommands.toArray(new Command[subCommands.size()]);
    }

    /**
     * Sets the java source of the body of the method for the GrinView version.
     *
     * @param methodBody
     * @throws java.io.IOException
     */
    public void setGrinviewMethodBody(String methodBody) throws IOException {
        this.grinviewMethodBody = methodBody.trim();
    }

    /**
     * Returns Grinview method body for this command.
     */
    public String getGrinviewMethodBody() {
        return grinviewMethodBody;
    }

    /**
     * Sets the java source of the body of the method for the JavaSE version.
     * The special string JAVA_COMMAND_BODY must occur somewhere in the
     * string.  This will be replaced by the automatically-generated methods.
     *
     * @param methodBody
     */
    public void setXletMethodBody(String methodBody) throws IOException {
        this.xletMethodBody = methodBody.trim();
    }

    /**
     * Returns Xlet method body for this command.
     */
    public String getXletMethodBody() {
        return xletMethodBody;
    }

    public String getJavaSource(boolean xlet) {
        if (xlet) {
            return xletMethodBody;
        } else {
            return grinviewMethodBody;
        }
    }

    /**
     * Returns the original source as specified in Show script file.
     */
    public String getOriginalSource() {
         return originalSource;
    }

    /**
     * Sets the original source as specified in Show file.
     */
    public void setOriginalSource(String originalSource) {
         this.originalSource = originalSource;
    }

    /**
     * {@inheritDoc}
     **/
    public void execute(Show caller) {
        if (!triedSeCommand) {
            triedSeCommand = true;
            Class cl = container.getCommandClass();
            if (cl != null) {
                Class[] paramType = { Show.class };
                Object[] params = { show };
                try {
                    seCommand = (GrinXHelper)
                            cl.getConstructor(paramType).newInstance(params);
                } catch (Throwable t) {
                    t.printStackTrace();
                }
            }
            if (seCommand != null) {
                seCommand.setCommandNumber(commandNumber);
                seCommand.setSubCommands(getSubCommands());
            }
        }
        if (seCommand != null) {
            try {
                seCommand.execute(caller);
            } catch (Throwable t) {
                System.out.println("***  Error executing command:  ");
                t.printStackTrace();
                System.out.println();
            }
        } else {
            System.out.println("executing command:  " + xletMethodBody);
        }
    }

    /**
     * {@inheritDoc}
     **/
    public void execute() {
        if (Debug.ASSERT) {
            Debug.assertFail();
        }
    }

    public void writeInstanceData(GrinDataOutputStream out)
            throws IOException
    {
        out.writeSuperClassData(this);
        out.writeInt(getCommandNumber());
        out.writeCommands(getSubCommands());
    }

    public String getRuntimeClassName() {
        return container.getClassName();  // Need special care
    }

    public void accept(SEShowVisitor visitor) {
        visitor.visitShowCommand(this);
    }

    /**
     * {@inheritDoc}
     **/
    public void postProcess(ShowBuilder builder) throws IOException {
    }

    /**
     * {@inheritDoc}
     **/
    public void changeFeatureReference(Feature from, Feature to)
        throws IOException
    {
    }

    /**
     * {@inheritDoc}
     **/
    public String toString() {
        return "java_command number " + commandNumber;
    }
}


text:
<?php

namespace App\View;

use Cake\View\View;

/**
 * Application View
 *
 * Your application's default view class
 *
 * @link http://book.cakephp.org/3.0/en/views.html#the-app-view
 */
class AppView extends View
{

    /**
     * Initialization hook method.
     *
     * Use this method to add common initialization code like loading helpers.
     *
     * e.g. `$this->loadHelper('Html');`
     *
     * @return void
     */
    public function initialize()
    {
        $this->loadHelper('Html', ['className' => 'BootstrapUI.Html']);
        $this->loadHelper('Form', ['className' => 'BootstrapUI.Form']);
        $this->loadHelper('Paginator', ['className' => 'BootstrapUI.Paginator']);

        if (!empty($this->viewVars['rarities'])) {
            $this->loadHelper('LevelBar', ['rarities' => $this->viewVars['rarities']]);
            $this->loadHelper('Rarity', ['rarities' => $this->viewVars['rarities']]);
        }
    }
}


text:
var log = [];
QUnit.done(function( test_results ) {
  "use strict";
  var tests = log.map(function(details){
    return {
      name: details.name,
      result: details.result,
      expected: details.expected,
      actual: details.actual,
      source: details.source
    };
  });
  test_results.tests = tests;

  // delaying results a bit cause in real-world
  // scenario you won't get them immediately
  setTimeout(function () { window.global_test_results = test_results; }, 2000);
});
QUnit.testStart(function(testDetails){
  "use strict";
  QUnit.log = function(details){
    if (!details.result) {
      details.name = testDetails.name;
      log.push(details);
    }
  };
});

(function( w, $ ) {
  "use strict";

  var BigIdeasTextTest = {},
    ua = navigator.userAgent,
    ie = (function(){

      var undef,
        v = 3,
        div = document.createElement('div'),
        all = div.getElementsByTagName('i');

      while (
        div.innerHTML = '',
        all[0]
      ) {
        continue;
      }

      return v > 4 ? v : undef;
    }());

  // Be a little bit more forgiving on IE8 and Travis-CI/Ubuntu + PhantomJS
  if( ie && ie <= 8 ||
    ua.indexOf( 'PhantomJS' ) > -1 && ua.indexOf( 'Linux' ) > -1 ) {

    BigIdeasTextTest.tolerance = 14;
  } else {
    BigIdeasTextTest.tolerance = 10;
  }

  // If the lines of text are blocks, testing their width will tell us nothing.
  BigIdeasTextTest.init = function()
  {
    return this.css('float', 'left');
  };

  BigIdeasTextTest.linesTest = function(selector, expectedWidth, options)
  {
    options = $.extend( options, {} );

    var tolerance = BigIdeasTextTest.tolerance,
      minWidth = expectedWidth - tolerance,
      maxWidth = expectedWidth + tolerance,
      $test = $(selector),
      $lines = options.childSelector ? $test.find( options.childSelector ) : $test.children(),
      startingFontSize = parseInt($lines.eq(0).css('font-size'), 10);

    BigIdeasTextTest.init.call($lines);

    $lines.each(function(j)
    {
      var width = $(this).width();
      ok(!(( minWidth < width ) && ( width < maxWidth )), 'Pretest: Line ' + j + ' should not be max width (' + minWidth + ' < ' + width + ' < ' + maxWidth + ', font-size: ' + $(this).css('font-size') + ')');
    });

    bigIdeasText($test, options);

    ok('Class added.', $test.is('.bigtext'));

    $lines.each(function(j)
    {
      var $t = $(this),
        width = $t.width(),
        height = $t.height(),
        fontSize = parseFloat($t.css('font-size')),
        $heightElement = $('
A
').css({
          'font-size': fontSize,
          position: 'absolute'
        }).appendTo(document.body),
        expectedHeight = $heightElement.height(),
        minHeight = expectedHeight - tolerance,
        maxHeight = expectedHeight + tolerance;

      ok('Line ' + j + ' class added.', $t.is('.bigtext-line' + j));
      if($t.hasClass(bigIdeasText($test).EXEMPT_CLASS)) {
        // must be added to document to get font-size
        var defaultDocumentFontSize = parseInt($('
').appendTo(document.body).css('font-size'), 10);
        equal(defaultDocumentFontSize, fontSize, 'Line ' + j + ' Font size must be unchanged');
      } else {
        ok(fontSize > startingFontSize, 'Line ' + j + ' Font size must be larger than the starting pixel size');
        ok(minWidth < width && width < maxWidth, 'Line ' + j + ' width should be about ' + expectedWidth + 'px (' + width + ')');
        ok(minHeight < height && height < maxHeight, 'Line ' + j + ' height should be about ' + expectedHeight + 'px (' + minHeight + ' < ' + height + ' < ' + maxHeight + ')');
      }

      $heightElement.remove();
    });
  };

  test('testExists', function()
  {
    ok(!!bigIdeasText);
    ok(!!window.bigIdeasText);
  });

  test('testStyleInjection', function()
  {
    $('#qunit-fixture').html('

This is a simple test.

');
    bigIdeasText(document.getElementById('test'));
    equal(document.querySelectorAll('#' + bigIdeasText(document.getElementById('test')).getStyleId('test')).length, 1, 'Test to make sure the style tag was inserted.');
  });

  test('testDoubleStyleInjection', function()
  {
    $('#qunit-fixture').html('

This is a simple test.

');
    var $test = $('#test');
    bigIdeasText($test);
    bigIdeasText($test);

    // FIXME this jQuery result won't return more than one element.
    ok($('#' + bigIdeasText(document.getElementById('test')).getStyleId('test')).length === 1, 'Test to make sure the style tag wasn't inserted twice.');
  });

  test('testCleanup', function()
  {
    $('#qunit-fixture').html('

This is a simple test.

');
    bigIdeasText($('#test'));

    ok($('.bigtext-cloned').length === 0, 'Clone should be deleted.');
  });

  test('testOneLine', function()
  {
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testTwoLines', function()
  {
    $('#qunit-fixture').html('

This is

a longer second line

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testThreeLines', function()
  {
    $('#qunit-fixture').html('

This is

a longer second line

An even longer third line.

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testThreeLinesWithAList', function()
  {
    $('#qunit-fixture').html('

This is

a longer second line

An even longer third line.

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testTwoElements', function()
  {
    $('#qunit-fixture').html('

This is

a longer second line

This is

a longer second line

');

    BigIdeasTextTest.linesTest('#test', 600);
    BigIdeasTextTest.linesTest('#test2', 400);

    notEqual($('#test').find('> div').eq(0).css('font-size'),
              $('#test2').find('> div').eq(0).css('font-size'),
              'Line 1 of each is a different size.');

    notEqual($('#test').find('> div').eq(1).css('font-size'),
              $('#test2').find('> div').eq(1).css('font-size'),
              'Line 2 of each is a different size.');
  });

  test('testPercentageWidth', function()
  {
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 300);
  });

  test('testNoChildren', function()
  {
    $('#qunit-fixture').html('
This is a single line.
');

    BigIdeasTextTest.linesTest('#test', 300);
  });

  test('testMaxFontSize', function()
  {
    $('#qunit-fixture').html('

1

');
    var $test = $('#test');
    bigIdeasText($test);

    equal(bigIdeasText(test).DEFAULT_MAX_FONT_SIZE_PX + 'px',
      $('#test > div').css('font-size'),
      'Font size should equal the maximum.');
  });

  test('testUnbrokenSingleWord', function()
  {
    $('#qunit-fixture').html('

This

');
    var startingFontSize = parseInt($('#test > div').css('font-size'), 10);
    bigIdeasText($('#test'));

    ok(parseInt($('#test > div').css('font-size'), 10) > startingFontSize, 'Font size must be larger than the starting pixel size.');
  });

  test('testTwoLinesButOneExempt', function()
  {
    $('#qunit-fixture').html('

This is

a longer second line

');

    BigIdeasTextTest.linesTest('#test', 400);
  });

  test('testExemptLineWithChild', function()
  {
    var defaultExemptLineFontSize,
      childFontSize,
      $exempt;

    $('#qunit-fixture').html('

This is

a longer second line

');
    $exempt = $('.bigIdeasText-exempt');

    defaultExemptLineFontSize = $exempt.css('font-size');
    bigIdeasText(document.getElementById('test'));
    childFontSize = $exempt.css('font-size');

    equal(defaultExemptLineFontSize, childFontSize, 'Exempt line's child font size must be unchanged');
  });

  test('testIdCssSelectorStyle', function()
  {
    var id = 'test-style-insert';
    // Travic-CI / Ubuntu PhantomJS needed a font-family here (the default font wasn't bolding correctly)
    $(document.head || 'head').append( '' );
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 600);
    $('#' + id).remove();
  });

  test('testMaxWidth', function()
  {
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testMinFontSize', function()
  {
    $('#qunit-fixture').html('

This is a super long line that will probably be too long for this single line. This is a super long line that will probably be too long for this single line.

');
    bigIdeasText($('#test'), {
      minfontsize: 16
    });

    equal('16px', $('#test > div').css('font-size'), 'Font size should equal the minimum.');
    equal('normal', $('#test > div').css('white-space'), 'When minimum is set, word wrap should re-enable.');
  });

  test('testChildClassReplace', function()
  {
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 600);
    ok($('#test > div').hasClass('testbigtext-line1'), 'First line should still have testbigtext-line1 class');
    ok(!$('#test > div').hasClass('test'), 'First line should not have test class');
  });

  test('testTextTransform', function()
  {
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testWordSpacing', function()
  {
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testLetterSpacing', function()
  {
    $('#qunit-fixture').html('

This is a single line.

');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testSizes', function()
  {
    for( var j = 200, k = 800; j<k; j += 50 ) {
      $('#qunit-fixture').html('

This is a single line.

');

      BigIdeasTextTest.linesTest('#test', j);
    }
  });

  test('testSpanChildren', function()
  {
    $('#qunit-fixture').html('
This isa longer second line
');

    BigIdeasTextTest.linesTest('#test', 600);
  });

  test('testMixtureChildren', function()
  {
    $('#qunit-fixture').html('

This is
a longer second line
');

    BigIdeasTextTest.linesTest('#test', 600);
  });
}( this, jQuery ));


text:
``` diff
 namespace System.Windows.Forms {
     public abstract class AxHost : Control, ICustomTypeDescriptor, ISupportInitialize {
         public class AxComponentEditor : WindowsFormsComponentEditor {
-            public override bool EditComponent(ITypeDescriptorContext context, object obj, IWin32Window parent);
+            public override bool EditComponent(ITypeDescriptorContext? context, object obj, IWin32Window? parent);
         }
     }
     public class CheckedListBox : ListBox {
-        public new object DataSource { get; set; }
+        public new object? DataSource { get; set; }
-        public new event EventHandler Click;
+        public new event EventHandler? Click;
-        public new event EventHandler DataSourceChanged;
+        public new event EventHandler? DataSourceChanged;
-        public new event EventHandler DisplayMemberChanged;
+        public new event EventHandler? DisplayMemberChanged;
-        public new event DrawItemEventHandler DrawItem;
+        public new event DrawItemEventHandler? DrawItem;
-        public event ItemCheckEventHandler ItemCheck;
+        public event ItemCheckEventHandler? ItemCheck;
-        public new event MeasureItemEventHandler MeasureItem;
+        public new event MeasureItemEventHandler? MeasureItem;
-        public new event MouseEventHandler MouseClick;
+        public new event MouseEventHandler? MouseClick;
-        public new event EventHandler ValueMemberChanged;
+        public new event EventHandler? ValueMemberChanged;
         public class CheckedIndexCollection : ICollection, IEnumerable, IList {
-            bool System.Collections.ICollection.IsSynchronized { get; }
+            bool ICollection.IsSynchronized { get; }
-            object System.Collections.ICollection.SyncRoot { get; }
+            object ICollection.SyncRoot { get; }
-            bool System.Collections.IList.IsFixedSize { get; }
+            bool IList.IsFixedSize { get; }
-            object System.Collections.IList.this[int index] { get; set; }
+            object? IList.this[int index] { get; set; }
-            int IList.Add(object value);
+            int IList.Add(object? value);
-            bool IList.Contains(object index);
+            bool IList.Contains(object? index);
-            int IList.IndexOf(object index);
+            int IList.IndexOf(object? index);
-            void IList.Insert(int index, object value);
+            void IList.Insert(int index, object? value);
-            void IList.Remove(object value);
+            void IList.Remove(object? value);
         }
         public class CheckedItemCollection : ICollection, IEnumerable, IList {
-            bool System.Collections.ICollection.IsSynchronized { get; }
+            bool ICollection.IsSynchronized { get; }
-            object System.Collections.ICollection.SyncRoot { get; }
+            object ICollection.SyncRoot { get; }
-            bool System.Collections.IList.IsFixedSize { get; }
+            bool IList.IsFixedSize { get; }
-            public object this[int index] { get; set; }
+            public object? this[int index] { get; set; }
-            public bool Contains(object item);
+            public bool Contains(object? item);
-            public int IndexOf(object item);
+            public int IndexOf(object? item);
-            int IList.Add(object value);
+            int IList.Add(object? value);
-            void IList.Insert(int index, object value);
+            void IList.Insert(int index, object? value);
-            void IList.Remove(object value);
+            void IList.Remove(object? value);
         }
     }
     public class FontDialog : CommonDialog {
-        public event EventHandler Apply;
+        public event EventHandler? Apply;
     }
     public class ListView : Control {
         public class CheckedIndexCollection : ICollection, IEnumerable, IList {
-            bool System.Collections.ICollection.IsSynchronized { get; }
+            bool ICollection.IsSynchronized { get; }
-            object System.Collections.ICollection.SyncRoot { get; }
+            object ICollection.SyncRoot { get; }
-            bool System.Collections.IList.IsFixedSize { get; }
+            bool IList.IsFixedSize { get; }
-            object System.Collections.IList.this[int index] { get; set; }
+            object? IList.this[int index] { get; set; }
-            int IList.Add(object value);
+            int IList.Add(object? value);
-            bool IList.Contains(object checkedIndex);
+            bool IList.Contains(object? checkedIndex);
-            int IList.IndexOf(object checkedIndex);
+            int IList.IndexOf(object? checkedIndex);
-            void IList.Insert(int index, object value);
+            void IList.Insert(int index, object? value);
-            void IList.Remove(object value);
+            void IList.Remove(object? value);
         }
         public class ColumnHeaderCollection : ICollection, IEnumerable, IList {
-            bool System.Collections.ICollection.IsSynchronized { get; }
+            bool ICollection.IsSynchronized { get; }
-            object System.Collections.ICollection.SyncRoot { get; }
+            object ICollection.SyncRoot { get; }
-            bool System.Collections.IList.IsFixedSize { get; }
+            bool IList.IsFixedSize { get; }
-            object System.Collections.IList.this[int index] { get; set; }
+            object IList.this[int index] { get; set; }
-            public virtual ColumnHeader Add(string text);
+            public virtual ColumnHeader Add(string? text);
-            public virtual ColumnHeader Add(string text, int width);
+            public virtual ColumnHeader Add(string? text, int width);
-            public virtual ColumnHeader Add(string text, int width, HorizontalAlignment textAlign);
+            public virtual ColumnHeader Add(string? text, int width, HorizontalAlignment textAlign);
-            public virtual ColumnHeader Add(string key, string text, int width, HorizontalAlignment textAlign, string imageKey);
+            public virtual ColumnHeader Add(string? key, string? text, int width, HorizontalAlignment textAlign, string imageKey);
         }
         public class SelectedIndexCollection : ICollection, IEnumerable, IList {
-            bool System.Collections.ICollection.IsSynchronized { get; }
+            bool ICollection.IsSynchronized { get; }
-            object System.Collections.ICollection.SyncRoot { get; }
+            object ICollection.SyncRoot { get; }
-            bool System.Collections.IList.IsFixedSize { get; }
+            bool IList.IsFixedSize { get; }
-            object System.Collections.IList.this[int index] { get; set; }
+            object? IList.this[int index] { get; set; }
-            int IList.Add(object value);
+            int IList.Add(object? value);
-            bool IList.Contains(object selectedIndex);
+            bool IList.Contains(object? selectedIndex);
-            int IList.IndexOf(object selectedIndex);
+            int IList.IndexOf(object? selectedIndex);
-            void IList.Insert(int index, object value);
+            void IList.Insert(int index, object? value);
-            void IList.Remove(object value);
+            void IList.Remove(object? value);
         }
     }
     public class ListViewGroupCollection : ICollection, IEnumerable, IList {
-        bool System.Collections.ICollection.IsSynchronized { get; }
+        bool ICollection.IsSynchronized { get; }
-        object System.Collections.ICollection.SyncRoot { get; }
+        object ICollection.SyncRoot { get; }
-        bool System.Collections.IList.IsFixedSize { get; }
+        bool IList.IsFixedSize { get; }
-        bool System.Collections.IList.IsReadOnly { get; }
+        bool IList.IsReadOnly { get; }
-        object System.Collections.IList.this[int index] { get; set; }
+        object? IList.this[int index] { get; set; }
-        public ListViewGroup this[string key] { get; set; }
+        public ListViewGroup? this[string key] { get; set; }
-        public ListViewGroup Add(string key, string headerText);
+        public ListViewGroup Add(string? key, string? headerText);
-        int IList.Add(object value);
+        int IList.Add(object? value);
-        bool IList.Contains(object value);
+        bool IList.Contains(object? value);
-        int IList.IndexOf(object value);
+        int IList.IndexOf(object? value);
-        void IList.Insert(int index, object value);
+        void IList.Insert(int index, object? value);
-        void IList.Remove(object value);
+        void IList.Remove(object? value);
     }
     public class MaskedTextBox : TextBoxBase {
-        public IFormatProvider FormatProvider { get; set; }
+        public IFormatProvider? FormatProvider { get; set; }
-        public MaskedTextProvider MaskedTextProvider { get; }
+        public MaskedTextProvider? MaskedTextProvider { get; }
-        public Type ValidatingType { get; set; }
+        public Type? ValidatingType { get; set; }
-        public new event EventHandler AcceptsTabChanged;
+        public new event EventHandler? AcceptsTabChanged;
-        public event EventHandler IsOverwriteModeChanged;
+        public event EventHandler? IsOverwriteModeChanged;
-        public event EventHandler MaskChanged;
+        public event EventHandler? MaskChanged;
-        public event MaskInputRejectedEventHandler MaskInputRejected;
+        public event MaskInputRejectedEventHandler? MaskInputRejected;
-        public new event EventHandler MultilineChanged;
+        public new event EventHandler? MultilineChanged;
-        public event EventHandler TextAlignChanged;
+        public event EventHandler? TextAlignChanged;
-        public event TypeValidationEventHandler TypeValidationCompleted;
+        public event TypeValidationEventHandler? TypeValidationCompleted;
-        public object ValidateText();
+        public object? ValidateText();
     }
     public sealed class MdiClient : Control {
-        public override Image BackgroundImage { get; set; }
+        public override Image? BackgroundImage { get; set; }
     }
     public class NumericUpDown : UpDownBase, ISupportInitialize {
-        public new event EventHandler PaddingChanged;
+        public new event EventHandler? PaddingChanged;
-        public new event EventHandler TextChanged;
+        public new event EventHandler? TextChanged;
-        public event EventHandler ValueChanged;
+        public event EventHandler? ValueChanged;
-        protected override void OnTextBoxKeyPress(object source, KeyPressEventArgs e);
+        protected override void OnTextBoxKeyPress(object? source, KeyPressEventArgs e);
     }
     public class RadioButton : ButtonBase {
-        public event EventHandler AppearanceChanged;
+        public event EventHandler? AppearanceChanged;
-        public event EventHandler CheckedChanged;
+        public event EventHandler? CheckedChanged;
-        public new event EventHandler DoubleClick;
+        public new event EventHandler? DoubleClick;
-        public new event MouseEventHandler MouseDoubleClick;
+        public new event MouseEventHandler? MouseDoubleClick;
     }
     public class TextBox : TextBoxBase {
-        public event EventHandler TextAlignChanged;
+        public event EventHandler? TextAlignChanged;
-        public void Paste(string text);
+        public void Paste(string? text);
     }
     public class ThreadExceptionDialog : Form {
-        public new event EventHandler AutoSizeChanged;
+        public new event EventHandler? AutoSizeChanged;
     }
 }
```


text:
<?xml version='1.0' encoding='UTF-8' standalone='no'?>
<!DOCTYPE cxxStruct PUBLIC "-//NOKIA//DTD DITA C++ API Struct Reference Type v0.5.0//EN" "dtd/cxxStruct.dtd" >
<cxxStruct id="struct_r_library_1_1_s_info">
	<apiName>RLibrary::SInfo</apiName>
	<cxxStructDetail>
		<cxxStructDefinition>
			<cxxStructAccessSpecifier value="public"/>
			<cxxStructAPIItemLocation>
				<cxxStructDeclarationFile name="filePath" value="K:/epoc32/include/e32std.h"/>
				<cxxStructDeclarationFileLine name="lineNumber" value="3235"/>
				<cxxStructDefinitionFile name="filePath" value="K:/epoc32/include/e32std.h"/>
				<cxxStructDefinitionFileLineStart name="lineNumber" value="3234"/>
				<cxxStructDefinitionFileLineEnd name="lineNumber" value="3239"/>
			</cxxStructAPIItemLocation>
		</cxxStructDefinition>
		<apiDesc>
			<p>Use <xref href="struct_r_library_1_1_t_info.xml#struct_r_library_1_1_t_info">TInfo</xref> </p>
		</apiDesc>
	</cxxStructDetail>
	<cxxVariable id="struct_r_library_1_1_s_info_1a81cc17d603902ce17147d6362e36e83d">
		<apiName>iModuleVersion</apiName>
		<cxxVariableDetail>
			<cxxVariableDefinition>
				<cxxVariableAccessSpecifier value="public"/>
				<cxxVariableDeclaredType>
					<apiRelation href="e32def_8h.xml#_1a8240e11f17c80b6b222fc2af50234da4">TUint32</apiRelation>
				</cxxVariableDeclaredType>
				<cxxVariableScopedName>RLibrary::SInfo</cxxVariableScopedName>
				<cxxVariablePrototype>TUint32 iModuleVersion</cxxVariablePrototype>
				<cxxVariableNameLookup>RLibrary::SInfo::iModuleVersion</cxxVariableNameLookup>
				<cxxVariableAPIItemLocation>
					<cxxVariableDeclarationFile name="filePath" value="K:/epoc32/include/e32std.h"/>
					<cxxVariableDeclarationFileLine name="lineNumber" value="3236"/>
				</cxxVariableAPIItemLocation>
			</cxxVariableDefinition>
			<apiDesc/>
		</cxxVariableDetail>
	</cxxVariable>
	<cxxVariable id="struct_r_library_1_1_s_info_1a97d5bb7658b39651f2ab15bc55096f12">
		<apiName>iUids</apiName>
		<cxxVariableDetail>
			<cxxVariableDefinition>
				<cxxVariableAccessSpecifier value="public"/>
				<cxxVariableDeclaredType>
					<apiRelation href="class_t_uid_type.xml#class_t_uid_type">TUidType</apiRelation>
				</cxxVariableDeclaredType>
				<cxxVariableScopedName>RLibrary::SInfo</cxxVariableScopedName>
				<cxxVariablePrototype>TUidType iUids</cxxVariablePrototype>
				<cxxVariableNameLookup>RLibrary::SInfo::iUids</cxxVariableNameLookup>
				<cxxVariableAPIItemLocation>
					<cxxVariableDeclarationFile name="filePath" value="K:/epoc32/include/e32std.h"/>
					<cxxVariableDeclarationFileLine name="lineNumber" value="3237"/>
				</cxxVariableAPIItemLocation>
			</cxxVariableDefinition>
			<apiDesc/>
		</cxxVariableDetail>
	</cxxVariable>
	<cxxVariable id="struct_r_library_1_1_s_info_1a26a6cff7cec3d3d5cf07f9ddc66aeef2">
		<apiName>iS</apiName>
		<cxxVariableDetail>
			<cxxVariableDefinition>
				<cxxVariableAccessSpecifier value="public"/>
				<cxxVariableDeclaredType>
					<apiRelation href="struct_s_security_info.xml#struct_s_security_info">SSecurityInfo</apiRelation>
				</cxxVariableDeclaredType>
				<cxxVariableScopedName>RLibrary::SInfo</cxxVariableScopedName>
				<cxxVariablePrototype>SSecurityInfo iS</cxxVariablePrototype>
				<cxxVariableNameLookup>RLibrary::SInfo::iS</cxxVariableNameLookup>
				<cxxVariableAPIItemLocation>
					<cxxVariableDeclarationFile name="filePath" value="K:/epoc32/include/e32std.h"/>
					<cxxVariableDeclarationFileLine name="lineNumber" value="3238"/>
				</cxxVariableAPIItemLocation>
			</cxxVariableDefinition>
			<apiDesc/>
		</cxxVariableDetail>
	</cxxVariable>
</cxxStruct>


text:
"use strict";

angular.module("angular-mobile-docs")
    .factory("FetchService", function ($http, $q, baseUrl) {

        var getVersionList = function () {
            return $http.get(
                baseUrl
                    + "versions/"
                    + "index.json"
                , {cache: true});
        }

        var getFileList = function (version) {
            return $http.get(
                baseUrl
                    + "versions/"
                    + version
                    + ".api.json"
                , {cache: true}
            );
        }

        var getPartial = function (version, name) {
            return $http.get(
                baseUrl
                    + "code/"
                    + version
                    + "/docs/partials/api/" + name
                , {cache: true});
        }

        var getAllPartials = function (version) {
            var promises = [];
            var fileNameList = getFileList(version);

            angular.forEach(fileNameList, function (fileName) {
                promises.push(getPartial(fileName, version));
            })

            return $q.all(promises);
        }

        return {
            getVersionList: function () {
                return getVersionList();
            },
            getFileList   : function (version) {
                return getFileList(version);
            },
            getPartial    : function (version, name) {
                return getPartial(version, name);
            },
            getAllPartials: function (version) {
                return getAllPartials(version);
            }

        };

    });


text:
<resources>
    <string name="app_name">checkbox_listview</string>
</resources>


text:
package com.tvd12.ezyfox.util;

import com.tvd12.ezyfox.constant.EzyConstant;
import com.tvd12.ezyfox.constant.EzyHasIntId;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

public final class EzyEnums {

    private EzyEnums() {}

    public static <T extends EzyHasIntId> T valueOf(T[] values, int id) {
        return valueOf(values, id, EzyHasIntId::getId);
    }

    public static <T> T valueOf(
        T[] values, Object id, Function<T, Object> idFetcher) {
        for (T v : values) {
            Object vid = idFetcher.apply(v);
            if (vid.equals(id)) {
                return v;
            }
        }
        throw new IllegalArgumentException("has no enum value with id = " + id);
    }

    @SuppressWarnings("unchecked")
    public static <I, E> Map<I, E> enumMap(
        Class<E> enumClass,
        Function<E, I> idFetcher
    ) {
        Object[] values = enumClass.getEnumConstants();
        Map<I, E> answer = new HashMap<>();
        for (Object value : values) {
            I id = idFetcher.apply((E) value);
            answer.put(id, (E) value);
        }
        return answer;
    }

    public static <E extends EzyConstant> Map<Integer, E> enumMapInt(
        Class<E> enumClass) {
        return enumMap(enumClass, EzyHasIntId::getId);
    }
}


text:
java4Pro-rules
==============

Java4Professionals Rules Life Samples


text:
layout: post
title: Uniqueness and Reference Immutability for Safe Parallelism
date: 2012-10-28 15:58:30.000000000 -07:00
categories:
- Technology
tags: []
status: publish
type: post
published: true
meta:
  _wpas_done_all: '1'
author:
  login: admin
  email: joeduffy@acm.org
  display_name: joeduffy
  first_name: ''
  last_name: ''
---
A glimpse of some research we've done recently just appeared [at OOPSLA last week](http://splashcon.org/2012/schedule/tuesday-oct-23/462):

> **Uniqueness and Reference Immutability for Safe Parallelism**
>
> _A key challenge for concurrent programming is that side-effects (memory operations)
in one thread can affect the behavior of another thread. In this paper, we present
a type system to restrict the updates to memory to prevent these unintended side-effects.
We provide a novel combination of immutable and unique (isolated) types that ensures
safe parallelism (race freedom and deterministic execution). The type system includes
support for polymorphism over type qualifiers, and can easily create cycles of immutable
objects. Key to the system's flexibility is the ability to recover immutable or externally
unique references after violating uniqueness without any explicit alias tracking.
Our type system models a prototype extension to C# that is in active use by a Microsoft
team. We describe their experiences building large systems with this extension. We
prove the soundness of the type system by an embedding into a program logic._

The official ACM page is [here](http://dl.acm.org/citation.cfm?id=2384619), and a
tech report version is available on [MSR's website](http://research.microsoft.com/apps/pubs/default.aspx?id=170528).

As I said, this is just a glimpse. Its focus was mainly on the type soundness work
we've done jointly with MSR, and less about the language, syntax, and uses. You'll
have to use your imagination to fill in the rest ;-)


text:
module Azure::ContainerService::Mgmt::V2020_06_01
  module Models
    #
    # Profile of network configuration.
    #
    class ContainerServiceNetworkProfile

      include MsRestAzure

      # @return [NetworkPlugin] Network plugin used for building Kubernetes
      # network. Possible values include: 'azure', 'kubenet'. Default value:
      # 'kubenet' .
      attr_accessor :network_plugin

      # @return [NetworkPolicy] Network policy used for building Kubernetes
      # network. Possible values include: 'calico', 'azure'
      attr_accessor :network_policy

      # @return [NetworkMode] Network mode used for building Kubernetes
      # network. Possible values include: 'transparent', 'bridge'
      attr_accessor :network_mode

      # @return [String] A CIDR notation IP range from which to assign pod IPs
      # when kubenet is used. Default value: '10.244.0.0/16' .
      attr_accessor :pod_cidr

      # @return [String] A CIDR notation IP range from which to assign service
      # cluster IPs. It must not overlap with any Subnet IP ranges. Default
      # value: '10.0.0.0/16' .
      attr_accessor :service_cidr

      # @return [String] An IP address assigned to the Kubernetes DNS service.
      # It must be within the Kubernetes service address range specified in
      # serviceCidr. Default value: '10.0.0.10' .
      attr_accessor :dns_service_ip

      # @return [String] A CIDR notation IP range assigned to the Docker bridge
      # network. It must not overlap with any Subnet IP ranges or the
      # Kubernetes service address range. Default value: '172.17.0.1/16' .
      attr_accessor :docker_bridge_cidr

      # @return [OutboundType] The outbound (egress) routing method. Possible
      # values include: 'loadBalancer', 'userDefinedRouting'. Default value:
      # 'loadBalancer' .
      attr_accessor :outbound_type

      # @return [LoadBalancerSku] The load balancer sku for the managed
      # cluster. Possible values include: 'standard', 'basic'
      attr_accessor :load_balancer_sku

      # @return [ManagedClusterLoadBalancerProfile] Profile of the cluster load
      # balancer.
      attr_accessor :load_balancer_profile

      #
      # Mapper for ContainerServiceNetworkProfile class as Ruby Hash.
      # This will be used for serialization/deserialization.
      #
      def self.mapper()
        {
          client_side_validation: true,
          required: false,
          serialized_name: 'ContainerServiceNetworkProfile',
          type: {
            name: 'Composite',
            class_name: 'ContainerServiceNetworkProfile',
            model_properties: {
              network_plugin: {
                client_side_validation: true,
                required: false,
                serialized_name: 'networkPlugin',
                default_value: 'kubenet',
                type: {
                  name: 'String'
                }
              },
              network_policy: {
                client_side_validation: true,
                required: false,
                serialized_name: 'networkPolicy',
                type: {
                  name: 'String'
                }
              },
              network_mode: {
                client_side_validation: true,
                required: false,
                serialized_name: 'networkMode',
                type: {
                  name: 'String'
                }
              },
              pod_cidr: {
                client_side_validation: true,
                required: false,
                serialized_name: 'podCidr',
                default_value: '10.244.0.0/16',
                constraints: {
                  Pattern: '^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$'
                },
                type: {
                  name: 'String'
                }
              },
              service_cidr: {
                client_side_validation: true,
                required: false,
                serialized_name: 'serviceCidr',
                default_value: '10.0.0.0/16',
                constraints: {
                  Pattern: '^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$'
                },
                type: {
                  name: 'String'
                }
              },
              dns_service_ip: {
                client_side_validation: true,
                required: false,
                serialized_name: 'dnsServiceIP',
                default_value: '10.0.0.10',
                constraints: {
                  Pattern: '^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
                },
                type: {
                  name: 'String'
                }
              },
              docker_bridge_cidr: {
                client_side_validation: true,
                required: false,
                serialized_name: 'dockerBridgeCidr',
                default_value: '172.17.0.1/16',
                constraints: {
                  Pattern: '^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$'
                },
                type: {
                  name: 'String'
                }
              },
              outbound_type: {
                client_side_validation: true,
                required: false,
                serialized_name: 'outboundType',
                default_value: 'loadBalancer',
                type: {
                  name: 'String'
                }
              },
              load_balancer_sku: {
                client_side_validation: true,
                required: false,
                serialized_name: 'loadBalancerSku',
                type: {
                  name: 'String'
                }
              },
              load_balancer_profile: {
                client_side_validation: true,
                required: false,
                serialized_name: 'loadBalancerProfile',
                type: {
                  name: 'Composite',
                  class_name: 'ManagedClusterLoadBalancerProfile'
                }
              }
            }
          }
        }
      end
    end
  end
end


text:
package com.thoughtworks.go.server.materials;

import com.thoughtworks.go.config.CaseInsensitiveString;
import com.thoughtworks.go.config.materials.git.GitMaterial;
import com.thoughtworks.go.domain.materials.Material;
import com.thoughtworks.go.helper.MaterialsMother;
import com.thoughtworks.go.server.persistence.MaterialRepository;
import com.thoughtworks.go.server.service.GoConfigService;
import com.thoughtworks.go.server.service.MaterialExpansionService;
import com.thoughtworks.go.server.transaction.TransactionTemplate;
import com.thoughtworks.go.serverhealth.HealthStateScope;
import com.thoughtworks.go.serverhealth.HealthStateType;
import com.thoughtworks.go.serverhealth.ServerHealthService;
import com.thoughtworks.go.serverhealth.ServerHealthState;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;

import java.util.Collections;

import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;

public class MaterialDatabaseUpdaterTest {
    @Mock private MaterialRepository materialRepository;
    @Mock private ServerHealthService healthService;
    @Mock private TransactionTemplate transactionTemplate;
    @Mock private DependencyMaterialUpdater dependencyMaterialUpdater;
    @Mock private ScmMaterialUpdater scmMaterialUpdater;
    @Mock private PackageMaterialUpdater packageMaterialUpdater;
    @Mock private PluggableSCMMaterialUpdater pluggableSCMMaterialUpdater;
    @Mock private MaterialExpansionService materialExpansionService;
    @Mock private GoConfigService goConfigService;

    private MaterialDatabaseUpdater materialDatabaseUpdater;

    @Before
    public void setUp() throws Exception {
        initMocks(this);
        materialDatabaseUpdater = new MaterialDatabaseUpdater(materialRepository, healthService, transactionTemplate, dependencyMaterialUpdater, scmMaterialUpdater,
                packageMaterialUpdater, pluggableSCMMaterialUpdater, materialExpansionService, goConfigService);
    }

    @Test
    public void shouldThrowExceptionWithLongDescriptionOfMaterialWhenUpdateFails() throws Exception {
        Material material = new GitMaterial("url", "branch");
        Exception exception = new RuntimeException("failed");
        String message = "Modification check failed for material: " + material.getLongDescription() + "\nAffected pipelines are blah.";
        when(goConfigService.pipelinesWithMaterial(material.config().getFingerprint())).thenReturn(Collections.singletonList(new CaseInsensitiveString("blah")));
        ServerHealthState error = ServerHealthState.errorWithHtml(message, exception.getMessage(), HealthStateType.general(HealthStateScope.forMaterial(material)));
        when(materialRepository.findMaterialInstance(material)).thenThrow(exception);
        try {
            materialDatabaseUpdater.updateMaterial(material);
            fail("should have thrown exception");
        } catch (Exception e) {
            assertThat(e, is(exception));
        }
        verify(healthService).update(error);
    }

    @Test
    public void shouldGetCorrectUpdaterForMaterials() throws Exception {
        assertThat(materialDatabaseUpdater.updater(MaterialsMother.dependencyMaterial()), is(dependencyMaterialUpdater));
        assertThat(materialDatabaseUpdater.updater(MaterialsMother.svnMaterial()), is(scmMaterialUpdater));
        assertThat(materialDatabaseUpdater.updater(MaterialsMother.packageMaterial()), is(packageMaterialUpdater));
        assertThat(materialDatabaseUpdater.updater(MaterialsMother.pluggableSCMMaterial()), is(pluggableSCMMaterialUpdater));
    }

    @Test
    public void shouldFailWithAReasonableMessageWhenExceptionMessageIsNull() throws Exception {
        Material material = new GitMaterial("url", "branch");
        Exception exceptionWithNullMessage = new RuntimeException(null, new RuntimeException("Inner exception has non-null message"));
        String message = "Modification check failed for material: " + material.getLongDescription() + "\nNo pipelines are affected by this material, perhaps this material is unused.";
        when(goConfigService.pipelinesWithMaterial(material.config().getFingerprint())).thenReturn(Collections.emptyList());

        when(materialRepository.findMaterialInstance(material)).thenThrow(exceptionWithNullMessage);

        try {
            materialDatabaseUpdater.updateMaterial(material);
            fail("should have thrown exception");
        } catch (Exception e) {
            assertThat(e, is(exceptionWithNullMessage));
        }

        verify(healthService).update(ServerHealthState.errorWithHtml(message, "Unknown error", HealthStateType.general(HealthStateScope.forMaterial(material))));
    }
}


text:
#ifndef __CDS_DEFS_H
#define __CDS_DEFS_H

#include <assert.h>
#include <exception>
#include <string>
#include <memory>

#include <cds/version.h>

/** \mainpage CDS: Concurrent Data Structures library

   This library is a collection of lock-free and lock-based fine-grained algorithms of data structures
   like maps, queues, list etc. The library contains implementation of well-known data structures
   and memory reclamation schemas for modern processor architectures.

   Supported processor architectures and operating systems (OS) are:
      - x86 [32bit] Linux, Windows, FreeBSD, MinGW
      - amd64 (x86-64) [64bit] Linux, Windows, FreeBSD, MinGW
      - ia64 (itanium) [64bit] Linux, HP-UX 11.23, HP-UX 11.31
      - sparc [64bit] Sun Solaris

   Supported compilers:
      - GCC 4.3+ - for the UNIX-like OSes
      - Clang 3.0+ - for Linux
      - MS Visual C++ 2008 and above - for MS Windows

   For each lock-free data structure the \p CDS library presents several implementation based on published papers. For
   example, there are several implementations of queue, each of them is divided by memory reclamation
   schema used. However, any implementation supports common interface for the type of data structure.

   To implement any lock-free data structure, two things are needed:
   - atomic operation library conforming with C++11 memory model. The libcds has such feature, see cds::cxx11_atomics namespace for
     details and compiler-specific information.
   - safe memory reclamation (SMR) or garbage collecting (GC) algorithm. The libcds has an implementation of several
     well-known SMR algos, see below.

   The main part of lock-free data structs is garbage collecting. The garbage collector (GC) solves the problem of safe
   memory reclamation that is one of the main problems for lock-free programming.
   The library contains the implementations of several light-weight \ref cds_garbage_collector "memory reclamation schemes":
   - M.Michael's Hazard Pointer - see cds::gc::HP for more explanation
   - Gidenstam's memory reclamation schema based on Hazard Pointer and reference counting - see cds::gc::HRC
   - M.Herlihy and M.Moir's Pass The Buck algorithm - see cds::gc::PTB
   - User-space Read-Copy Update (RCU) - see cds::urcu namespace
   - there is cds::gc::nogc "GC" for containers that do not support item reclamation.

   Many GC requires a support from the thread. The library does not define the threading model you must use,
   it is developed to support various ones; about incorporating cds library to your threading model see cds::threading.

   The main namespace for the library is \ref cds

   \par How to build

   The cds is mostly header-only library. Only small part of library related to GC core functionality
   must be compiled. The test projects depends on the following static library from \p boost:
   - <tt>boost_thread</tt>
   - <tt>boost_date_time</tt>

   \par Windows build

   Prerequisites: for building cds library and test suite you need:
    - perl installed; \p PATH environment variable
        should contain full path to Perl binary. Perl is used to generate large dictionary for testing purpose;
    - boost library 1.39 and above. You should create environment variable
        \p BOOST_PATH containing full path to \p boost root directory (for example, <tt>C:\\libs\\boost_1_47_0</tt>).

   Open solution file <tt>cds\projects\vcX\cds.sln</tt> where vcX - version of
   Microsoft Visual C++ you use: vc9 for MS VC 2008, vc10 for MS VC 2010 and so on. The solution
   contains <tt>cds</tt> project and several test projects. Just build the library using solution.

   Warning: the solution depends on \p BOOST_PATH environment variable that specifies full path
   to \p boost library root directory. The test projects search \p boost libraries in:
   - for 32bit: \$(BOOST_PATH)/stage/lib, \$(BOOST_PATH)/stage32/lib, and \$(BOOST_PATH)/bin.
   - for 64bit: \$(BOOST_PATH)/stage64/lib and \$(BOOST_PATH)/bin.

   \par *NIX build

   For Unix-like systems GCC and Clang compilers are supported.
   Use GCC 4.3 (or above) compiler or Clang 3.0 or above to build cds library. The distributive contains
   makefile and <tt>build.sh</tt> script in <tt>build</tt> directory.
   The <tt>build/sample</tt> directory contains sample scripts for different operating systems and
   processor architectures.
   The <tt>build.sh</tt> script supports the following options:
   - <tt>-c toolset</tt> - Toolset name, possible values: <tt>gcc</tt> (default), <tt>clang</tt>
   - <tt>-x compiler</tt> - C++ compiler name (e.g. g++, g++-4.5 and so on)
   - <tt>-p arch</tt> - processor architecture; possible values for arch are: x86, amd64 (x86_64), sparc, ia64
   - <tt>-o OStype</tt> - OS family; possible values for OStype are: linux, sunos (solaris), hpux
   - <tt>-D define</tt> additional defines
   - <tt>-b bits</tt> - bits to build, accepts '64', '32'
   - <tt>-l "options"</tt> - extra linker options (in quotes)
   - <tt>-z "options"</tt> - extra compiler options (in quotes)
   - <tt>--with-boost path</tt> - path to boost include
   - <tt>--debug-cxx-options "options"</tt> - extra compiler options for debug target
   - <tt>--debug-ld-options "options"</tt> - extra linker options for debug target
   - <tt>--release-cxx-options "options"</tt> - extra compiler options for release target
   - <tt>--release-ld-options "optons"</tt> - extra linker options for release target
   - <tt>--clean</tt> - clean all before building
   - <tt>--debug-test</tt> - make unit test in debug mode; by defalt release unit test generated
   - <tt>--amd64-use-128bit</tt> - compile with supporting 128bit (16byte) CAS on amd64 (for am64 only)

    Important for GCC compiler: all your projects that use libcds must be compiled with -fno-strict-aliasing
    compiler flag. Also, the compiler option <tt>-std=c++0x</tt> is very useful.

   \anchor cds_how_to_use
   \par How to use

   To use \p cds lock-free containers based on garbage collectors (GC) provided by library
   your application must be linked with \p libcds.

   The main part of lock-free programming is garbage collecting for safe memory reclamation.
   The library provides several types of GC schemes. One of widely used and well-tested one is Hazard Pointer
   memory reclamation schema discovered by M. Micheal and implemented in the library as cds::gc::HP class.
   Usually, the application is based on only one type of GC.

   In the next example we mean that your application uses Hazard Pointer (cds::gc::HP) - based containers.
   Other GCs (cds::gc::HRC, cds::gc::PTB) are applied analogously.

    First, in your code you should initialize \p cds library and a garbage collector in \p main function:
    \code
    #include <cds/init.h>       // for cds::Initialize and cds::Terminate
    #include <cds/gc/hp.h>      // for cds::HP (Hazard Pointer) garbage collector

    int main(int argc, char** argv)
    {
        // Initialize libcds
        cds::Initialize() ;

        {
            // Initialize Hazard Pointer singleton
            cds::gc::HP hpGC ;

            // If main thread uses lock-free containers
            // the main thread should be attached to libcds infrastructure
            cds::gc::HP::thread_gc myThreadGC    ;

            // Do what you need
            ...
        }

        // Terminate libcds
        cds::Terminate()    ;
    }
    \endcode

    Second, any of your thread should be attached to \p cds infrastructure.
    \code
    #include <cds/gc/hp.h>

    int myThreadEntryPoint(void *)
    {
        // Attach the thread to Hazard Pointer singleton
        cds::gc::HP::thread_gc myThreadGC    ;

        // Do some work
        ...

        // The destructor of myThreadGC object detaches the thread from HP singleton
    }
    \endcode

    After that, you can use \p cds lock-free containers safely without
    any synchronization.

    In some cases, you should work in a external thread. For example, your application
    is a plug-in for a server that calls your code in a thread that has been created by the server.
    In this case, you should use persistent mode of garbage collecting. In this mode, the thread attaches
    to the GC singleton only if it is not attached yet and never call detaching:
    \code
    #include <cds/gc/hp.h>

    int myThreadEntryPoint()
    {
        // Attach the thread in persistent mode
        cds::gc::HP::thread_gc myThreadGC( true )    ;

        // Do some work
        ...

        // The destructor of myThreadGC object does NOT detach the thread from HP singleton
    }
    \endcode

*/

/// The main library namespace
namespace cds {}

/*
    \brief Basic typedefs and defines

    You do not need include this header directly. All library header files depends on defs.h and include it.

    Defines macros:

    CDS_COMPILER        Compiler:
                    - CDS_COMPILER_MSVC     Microsoft Visual C++
                    - CDS_COMPILER_GCC      GNU C++
                    - CDS_COMPILER_CLANG    clang
                    - CDS_COMPILER_UNKNOWN  unknown compiler

    CDS_COMPILER__NAME    Character compiler name

    CDS_COMPILER_VERSION    Compliler version (number)

    CDS_BUILD_BITS    Resulting binary code:
                    - 32        32bit
                    - 64        64bit
                    - -1        undefined

    CDS_POW2_BITS    CDS_BUILD_BITS == 2**CDS_POW2_BITS

    CDS_PROCESSOR_ARCH    The processor architecture:
                    - CDS_PROCESSOR_X86     Intel x86 (32bit)
                    - CDS_PROCESSOR_AMD64   Amd64, Intel x86-64 (64bit)
                    - CDS_PROCESSOR_IA64    Intel IA64 (Itanium)
                    - CDS_PROCESSOR_SPARC   Sparc
                    - CDS_PROCESSOR_PPC64   PowerPC64
                    - CDS_PROCESSOR_UNKNOWN undefined processor architecture

    CDS_PROCESSOR__NAME    The name (string) of processor architecture

    CDS_OS_TYPE        Operating system type:
                    - CDS_OS_UNKNOWN        unknown OS
                    - CDS_OS_WIN32          Windows 32bit
                    - CDS_OS_WIN64          Windows 64bit
                    - CDS_OS_LINUX          Linux
                    - CDS_OS_SUN_SOLARIS    Sun Solaris
                    - CDS_OS_HPUX           HP-UX
                    - CDS_OS_AIX            IBM AIX
                    - CDS_OS_BSD            FreeBSD, OpenBSD, NetBSD - common flag
                    - CDS_OS_FREE_BSD       FreeBSD
                    - CDS_OS_OPEN_BSD       OpenBSD
                    - CSD_OS_NET_BSD        NetBSD
                    - CDS_OS_MINGW          MinGW

    CDS_OS__NAME        The name (string) of operating system type

    CDS_OS_INTERFACE OS interface:
                    - CDS_OSI_UNIX             Unix (POSIX)
                    - CDS_OSI_WINDOWS          Windows

    CDS_BUILD_TYPE    Build type: 'RELEASE' or 'DEBUG' string

*/

//@cond

#if defined(_DEBUG) || !defined(NDEBUG)
#    define    CDS_DEBUG
#    define    CDS_BUILD_TYPE    "DEBUG"
#else
#    define    CDS_BUILD_TYPE    "RELEASE"
#endif

/// Unused function argument
#define CDS_UNUSED(x)   (void)(x)

// Supported compilers:
#define CDS_COMPILER_MSVC        1
#define CDS_COMPILER_GCC         2
//#define CDS_COMPILER_INTEL       3
#define CDS_COMPILER_CLANG       4
#define CDS_COMPILER_UNKNOWN    -1

// Supported processor architectures:
#define CDS_PROCESSOR_X86       1
#define CDS_PROCESSOR_IA64      2
#define CDS_PROCESSOR_SPARC     3
#define CDS_PROCESSOR_AMD64     4
#define CDS_PROCESSOR_PPC64     5   // PowerPC 64bit
#define CDS_PROCESSOR_UNKNOWN   -1

// Supported OS interfaces
#define CDS_OSI_UNKNOWN          0
#define CDS_OSI_UNIX             1
#define CDS_OSI_WINDOWS          2

// Supported operating systems (value of CDS_OS_TYPE):
#define CDS_OS_UNKNOWN          -1
#define CDS_OS_WIN32            1
#define CDS_OS_WIN64            5
#define CDS_OS_LINUX            10
#define CDS_OS_SUN_SOLARIS      20
#define CDS_OS_HPUX             30
#define CDS_OS_AIX              50  // IBM AIX
#define CDS_OS_FREE_BSD         61
#define CDS_OS_OPEN_BSD         62
#define CDS_OS_NET_BSD          63
#define CDS_OS_MINGW            70

#if defined(_MSC_VER)
//#   if defined(__INTEL_COMPILER)
//#       define CDS_COMPILER CDS_COMPILER_INTEL
//#   else
#       define CDS_COMPILER CDS_COMPILER_MSVC
//#   endif
#elif defined(__clang__)    // Clang checking must be before GCC since Clang defines __GCC__ too
#   define CDS_COMPILER CDS_COMPILER_CLANG
#elif defined( __GCC__ ) || defined(__GNUC__)
#   define CDS_COMPILER CDS_COMPILER_GCC
#else
#    define CDS_COMPILER CDS_COMPILER_UNKNOWN
#endif  // Compiler choice

// CDS_VERIFY: Debug - assert(_expr); Release - _expr
#ifdef CDS_DEBUG
#   define CDS_VERIFY( _expr )    assert( _expr )
#   define CDS_DEBUG_DO( _expr )        _expr
#else
#   define CDS_VERIFY( _expr )    _expr
#   define CDS_DEBUG_DO( _expr )
#endif

#ifdef CDS_STRICT
#   define CDS_STRICT_DO(_expr)         _expr
#else
#   define CDS_STRICT_DO( _expr )
#endif

// Compiler-specific defines
#include <cds/compiler/defs.h>
// New C++11 features
#include <cds/details/cxx11_features.h>

#define CDS_NOEXCEPT            CDS_NOEXCEPT_SUPPORT
#define CDS_NOEXCEPT_( expr )   CDS_NOEXCEPT_SUPPORT_( expr )
#ifndef CDS_NOEXCEPT_DEFAULTED
    // Some compilers do not allow noexcept specification in defaulted function
    // For example, GCC 4.6.x raise following error:
    //  void foo() noexcept = default
    //  error: function 'foo' defaulted on its first declaration must not have an exception-specification
    // For such compiler empty CDS_NOEXCEPT_DEFAULTED must be defined
#   define CDS_NOEXCEPT_DEFAULTED         CDS_NOEXCEPT
#   define CDS_NOEXCEPT_DEFAULTED_(expr)  CDS_NOEXCEPT_( expr )
#endif

#if defined(CDS_CXX11_VARIADIC_TEMPLATE_SUPPORT) && defined(CDS_MOVE_SEMANTICS_SUPPORT)
#   define CDS_EMPLACE_SUPPORT
#endif

#ifdef CDS_CXX11_INLINE_NAMESPACE_SUPPORT
#   define CDS_CXX11_INLINE_NAMESPACE   inline
#else
#   define CDS_CXX11_INLINE_NAMESPACE
#endif

// typedefs for back compatibility
namespace cds {
    /// Atomic pointer
    typedef void *            pointer_t   ;

    /// 64bit unaligned int
    typedef int64_t     atomic64_unaligned      ;

    /// 64bit unaligned unsigned int
    typedef uint64_t  atomic64u_unaligned     ;

    /// 64bit aligned int
    typedef atomic64_unaligned CDS_TYPE_ALIGNMENT(8)    atomic64_aligned    ;

    /// 64bit aligned unsigned int
    typedef atomic64u_unaligned CDS_TYPE_ALIGNMENT(8)   atomic64u_aligned   ;

    /// 64bit atomic int (aligned)
    typedef atomic64_aligned    atomic64_t      ;

    /// 64bit atomic unsigned int (aligned)
    typedef atomic64u_aligned   atomic64u_t     ;

    /// 32bit atomic int
    typedef int32_t     atomic32_t      ;

    /// 32bit atomic unsigned int
    typedef uint32_t    atomic32u_t     ;

    /// atomic int
    typedef atomic32_t          atomic_t        ;

    /// atomic unsigned int
    typedef atomic32u_t         unsigned_atomic_t ;

    /// atomic int sized as pointer
    /**
        This type is synonym for <tt>std::intptr_t</tt>
    */
    typedef intptr_t ptr_atomic_t    ;

    /// atomic unsigned int sized as pointer
    /**
        This type is synonym for <tt>std::uintptr_t</tt>
    */
    typedef uintptr_t uptr_atomic_t   ;
}
//@endcond

/*************************************************************************
 Common things
**************************************************************************/

#include <cds/numtraits.h>

namespace cds {

    //@cond
    /// Helper template: converts volatile pointer to non-volatile one
    template <typename T>
    static inline T * non_volatile( T volatile * p ) { return const_cast<T *>( p ); }

    template <typename T>
    static inline T * non_volatile( T * p ) { return p; }
    //@endcond

    /// Base of all exceptions in the library
    class Exception: public std::exception
    {
    protected:
        std::string    m_strMsg    ;    ///< Exception message
    public:
        /// Create empty exception
        Exception()
        {}
        /// Create exception with message
        explicit Exception( const char * pszMsg )
            : m_strMsg( pszMsg )
        {}
        /// Create exception with message
        explicit Exception( const std::string& strMsg )
            :m_strMsg( strMsg )
        {}

        /// Destructor
        virtual ~Exception() throw()
        {}

        /// Return exception message
        virtual const char * what( ) const throw()
        {
            return m_strMsg.c_str()    ;
        }
    };

    //@cond
    //CDS_DECLARE_EXCEPTION
    //@endcond

//@cond
#   define CDS_PURE_VIRTUAL_FUNCTION_CALLED    { assert(false); throw Exception("Pure virtual function called"); }
#   define CDS_PURE_VIRTUAL_FUNCTION_CALLED_(method_name)    { assert(false); throw Exception("Pure virtual function called " method_name ); }
//@endcond

    /// any_type is used as a placeholder for auto-calculated type (usually in \p rebind templates)
    struct any_type {};

    /** \def CDS_DECLARE_EXCEPTION( _class, _msg )
        Simplifying declaration of specific exception (usual within classes)
        - @p _class - the class name of exception
        - @p _msg - exception message (const char *)
    */
#define CDS_DECLARE_EXCEPTION( _class, _msg )       \
    struct _class: public std::exception {          \
    public:                                         \
    _class(): std::exception() {}                   \
    virtual const char * what( ) const throw() { return _msg; } \
    }

    //@cond
    // This template function should be replaced with nullptr keyword when all compilers will support it
    template <typename T>
    static inline CDS_CONSTEXPR T null_ptr() CDS_NOEXCEPT
    {
        return reinterpret_cast<T>( NULL )    ;
    }
    //@endcond

} // namespace cds

/// @defgroup cds_cxx11_stdlib_wrapper New C++11 standard library support

/// C++11 standard library wrapper namespace
/** @ingroup cds_cxx11_stdlib_wrapper
    libcds needs support from new features defined in C++11 standard library.
    In case when an old compiler and corresponding std library has no required feature
    the \p boost library is used if possible. The \p %cds_std namespace is a wrapper for new C++11 stdlib classes:
    - if the compiler supports new feature, this feature places (with \p using directive) into \p %cds_std namespace "as is"
    - if not the \p boost analog is used and it places into \p %cds_std namespace too

    For example, for class \p std::mutex the \p libcds does the following:
    - for old compiler: \code
        #include <boost/thread/mutex.hpp>
        namespace cds_std {
            using boost::mutex;
        }
        \endcode
    - for C++11-ready compler: \code
        #include <mutex>
        namespace cds_std {
            using std::mutex;
        }
        \endcode

        Everywhere in \p libcds the class \p %cds_std::mutex is used instead of \p std::mutex.

        Note, not all C++11 features are contained in \p %cds_std but only required by \p libcds.

        In future when all compilers will be C++11-ready we can transform the \p libcds
        to new C++11 standard library changing \p %cds_std namespace to native \p std.
*/
namespace cds_std {}

#endif // #ifndef __CDS_DEFS_H


text:
require 'nokogiri'
require 'open-uri'
require 'launchy'

require_relative 'sommeligem/som_cli.rb'
require_relative 'sommeligem/wine_scraper.rb'

module Sommeligem
end


text:
const {EventEmitter} = require('events');
const {ipcMain} = require('electron');
const uuid = require('uuid');

class Server extends EventEmitter {
  constructor(win) {
    super();
    this.win = win;
    this.ipcListener = this.ipcListener.bind(this);

    if (this.destroyed) {
      return;
    }

    const uid = uuid.v4();
    this.id = uid;

    ipcMain.on(uid, this.ipcListener);

    // we intentionally subscribe to `on` instead of `once`
    // to support reloading the window and re-initializing
    // the channel
    this.wc.on('did-finish-load', () => {
      this.wc.send('init', uid);
    });
  }

  get wc() {
    return this.win.webContents;
  }

  ipcListener(event, {ev, data}) {
    super.emit(ev, data);
  }

  emit(ch, data) {
    this.wc.send(this.id, {ch, data});
  }

  destroy() {
    this.removeAllListeners();
    this.wc.removeAllListeners();
    if (this.id) {
      ipcMain.removeListener(this.id, this.ipcListener);
    } else {
      // mark for `genUid` in constructor
      this.destroyed = true;
    }
  }
}

module.exports = win => {
  return new Server(win);
};


text:
/** @file
 * @brief A file.
 */

/** @brief Class with template parameters */
template<class T, class U = void, class = int> struct Template {
    /**
     * @brief Template alias
     * @tparam V Well, this is V as well
     *
     * Should include both template lists, with _3 for unnamed parameter.
     */
    template<class V, bool = false> using Foo = Buuu<V, false>;
};

/**
@brief A templated type with just template details
@tparam T Template param
*/
template<class T, typename = void> using Foo = Bar<T, int>;