public void ContainsTest()
{
const Int32 count = 1000000;
// generate ip
var ipArray = new UInt32[count];
for (var index = 0; index < count; index++)
{
ipArray[index] = (UInt32)random.Next();
}
var resultArray = new Boolean[count];
var testResult = LoadTest.Execute
(
"ContainsTest",
index =>
{
var ipAddress = ipArray[index];
resultArray[index] = geolocationTree.Contains(ipAddress);
},
count
);
Trace.WriteLine(testResult.ToString());
Trace.TraceInformation("Result is {0} hits and {1} misses", resultArray.Count(x => x), resultArray.Count(x => x == false));
}
private static String[] GetMissingScript(ScriptTB ScriptToCheck, List <KeyValuePair <String, ScriptTB> > BlockScript)
{
try
{
Boolean[] ScriptReciveState = new Boolean[ScriptToCheck.CommandCounter.Value];
ScriptReciveState[ScriptToCheck.ExecutionNumber - 1] = true;
foreach (KeyValuePair <String, ScriptTB> ThisScript in BlockScript)
{
ScriptReciveState[ThisScript.Value.ExecutionNumber - 1] = true;
}
List <String> Missing = new List <String>();
for (int i = 0; i < ScriptReciveState.Count(); i++)
{
if (!ScriptReciveState[i])
{
Missing.Add((i + 1).ToString());
}
}
return(Missing.ToArray());
}
catch
{
}
return(null);
}
public bool isValid(params Role[] roles)
{
Boolean[] isRolePresentFlag = new Boolean[restrictedRoleIds.Length];
for (Int32 i = 0; i < restrictedRoleIds.Length; i++)
{
isRolePresentFlag[i] = roles.Count((v) => { return(v.Id == restrictedRoleIds[i]); }) > 0;
}
return(isRolePresentFlag.Count((b) => { return b == true; }) <= 1);
}
static void Main(string[] args)
{
var nk = Console.ReadLine().Split(" ")
.Select(i => int.Parse(i)).ToArray();
var n = nk[0];
var k = nk[1];
var people = new Boolean[n];
for (var i = 0; i < k; i++)
{
var d = int.Parse(Console.ReadLine());
foreach (var pi in Console.ReadLine().Split(" ").Select(i => int.Parse(i)).ToArray())
{
people[pi - 1] = true;
}
}
var count = people.Count(b => b == false);
Console.WriteLine(count);
}
internal Byte[] PerformEmitting(UInt32 currentOffset, out Boolean isTiny)
{
if (this._methodIL._labelOffsets.Any(offset => offset == MethodILImpl.NO_OFFSET))
{
throw new InvalidOperationException("Not all labels have been marked.");
}
if (this._methodIL._currentExceptionBlocks.Any())
{
throw new InvalidOperationException("Not all exception blocks have been completed.");
}
// Remember that inner exception blocks must precede outer ones
var allExceptionBlocksCorrectlyOrdered = this._methodIL._allExceptionBlocks.ToArray();
Array.Sort(
allExceptionBlocksCorrectlyOrdered,
(item1, item2) =>
{
// Return -1 if item1 is inner block of item2, 0 if they are same, 1 if item1 is not inner block of item2
return(Object.ReferenceEquals(item1, item2) ? 0 :
(item1._tryOffset >= item2._handlerOffset + item2._handlerLength || (item1._tryOffset <= item2._tryOffset && item1._handlerOffset + item1._handlerLength > item2._handlerOffset + item2._handlerLength) ? 1 : -1));
});
// Setup stack sizes based on exception blocks
foreach (var block in allExceptionBlocksCorrectlyOrdered)
{
switch (block._blockType)
{
case ExceptionBlockType.Exception:
this._stackSizes[block._handlerOffset] = 1;
break;
case ExceptionBlockType.Filter:
this._stackSizes[block._handlerOffset] = 1;
this._stackSizes[block._filterOffset] = 1;
break;
}
}
// Emit opcodes and arguments
foreach (var info in this._methodIL._opCodes)
{
info.EmitOpCode(this);
++this._methodILOffset;
}
// Mark label targets
for (var i = 0; i < this._labelInfoIndex; ++i)
{
var thisOffset = this._labelInfos[i].byteOffset;
var startCountOffset = this._labelInfos[i].startCountOffset;
var amountToJump = this._opCodeInfoOffsets[this._methodIL._labelOffsets[this._labelInfos[i].labelIdx]] - (thisOffset + startCountOffset);
if (startCountOffset == 1)
{
if (amountToJump >= SByte.MinValue && amountToJump <= SByte.MaxValue)
{
this._ilCode.WriteSByteToBytes(ref thisOffset, amountToJump);
}
else
{
throw new InvalidOperationException("Tried to use one-byte branch instruction for offset of amount " + amountToJump);
}
}
else
{
this._ilCode.WriteInt32LEToBytes(ref thisOffset, amountToJump);
}
}
// Create exception blocks with byte offsets
byte[][] exceptionBlocks = new byte[allExceptionBlocksCorrectlyOrdered.Length][];
Boolean[] exceptionFormats = new Boolean[exceptionBlocks.Length];
// TODO PEVerify doesn't like mixed small and fat blocks at all (however, at least Cecil understands that kind of situation)
// TODO Apparently, PEVerify doesn't like multiple small blocks either (Cecil still loads code fine)
// Also, because of exception block ordering, it is easier to do this way.
var allAreSmall = allExceptionBlocksCorrectlyOrdered.Length <= MAX_SMALL_EXC_HANDLERS_IN_ONE_SECTION &&
allExceptionBlocksCorrectlyOrdered.All(excBlock =>
{
var tryOffset = this._opCodeInfoOffsets[excBlock._tryOffset];
var tryLength = this._opCodeInfoOffsets[excBlock._tryOffset + excBlock._tryLength] - tryOffset;
var handlerOffset = this._opCodeInfoOffsets[excBlock._handlerOffset];
var handlerLength = this._opCodeInfoOffsets[excBlock._handlerOffset + excBlock._handlerLength] - handlerOffset;
return(tryLength <= Byte.MaxValue && handlerLength <= Byte.MaxValue && tryOffset <= UInt16.MaxValue && handlerOffset <= UInt16.MaxValue);
});
for (var i = 0; i < exceptionBlocks.Length; ++i)
{
// ECMA-335, pp. 286-287
var block = allExceptionBlocksCorrectlyOrdered[i];
Int32 idx = 0;
Byte[] array;
var tryOffset = this._opCodeInfoOffsets[block._tryOffset];
var tryLength = this._opCodeInfoOffsets[block._tryOffset + block._tryLength] - tryOffset;
var handlerOffset = this._opCodeInfoOffsets[block._handlerOffset];
var handlerLength = this._opCodeInfoOffsets[block._handlerOffset + block._handlerLength] - handlerOffset;
var useSmallFormat = allAreSmall &&
tryLength <= Byte.MaxValue && handlerLength <= Byte.MaxValue && tryOffset <= UInt16.MaxValue && handlerOffset <= UInt16.MaxValue;
exceptionFormats[i] = useSmallFormat;
if (useSmallFormat)
{
array = new Byte[12];
array.WriteInt16LEToBytes(ref idx, (Int16)block._blockType)
.WriteUInt16LEToBytes(ref idx, (UInt16)tryOffset)
.WriteByteToBytes(ref idx, (Byte)tryLength)
.WriteUInt16LEToBytes(ref idx, (UInt16)handlerOffset)
.WriteByteToBytes(ref idx, (Byte)handlerLength);
}
else
{
array = new Byte[24];
array.WriteInt32LEToBytes(ref idx, (Int32)block._blockType)
.WriteInt32LEToBytes(ref idx, tryOffset)
.WriteInt32LEToBytes(ref idx, tryLength)
.WriteInt32LEToBytes(ref idx, handlerOffset)
.WriteInt32LEToBytes(ref idx, handlerLength);
}
if (ExceptionBlockType.Exception == block._blockType)
{
array.WriteInt32LEToBytes(ref idx, this._metaData.GetTokenFor(this._assemblyMapper == null ? block._exceptionType : this._assemblyMapper.MapTypeBase(block._exceptionType), false));
}
else if (ExceptionBlockType.Filter == block._blockType)
{
array.WriteInt32LEToBytes(ref idx, block._filterOffset);
}
exceptionBlocks[i] = array;
}
// Write method header, extra data sections, and IL
Byte[] result;
isTiny = this._ilCodeCount < 64 &&
exceptionBlocks.Length == 0 &&
this._maxStack <= 8 &&
this._methodIL._locals.Count == 0;
var resultIndex = 0;
var hasAnyExc = false;
var hasSmallExc = false;
var hasLargExc = false;
var smallExcCount = 0;
var largeExcCount = 0;
var amountToNext4ByteBoundary = 0;
if (isTiny)
{
// Can use tiny header
result = new Byte[this._ilCodeCount + 1];
result[resultIndex++] = (Byte)((Int32)MethodHeaderFlags.TinyFormat | (this._ilCodeCount << 2));
}
else
{
// Use fat header
hasAnyExc = exceptionBlocks.Length > 0;
hasSmallExc = hasAnyExc && exceptionFormats.Any(excFormat => excFormat);
hasLargExc = hasAnyExc && exceptionFormats.Any(excFormat => !excFormat);
smallExcCount = hasSmallExc ? exceptionFormats.Count(excFormat => excFormat) : 0;
largeExcCount = hasLargExc ? exceptionFormats.Count(excFormat => !excFormat) : 0;
var offsetAfterIL = (Int32)(BitUtils.MultipleOf4(currentOffset) + 12 + (UInt32)this._ilCodeCount);
amountToNext4ByteBoundary = BitUtils.MultipleOf4(offsetAfterIL) - offsetAfterIL;
result = new Byte[12
+ this._ilCodeCount +
(hasAnyExc ? amountToNext4ByteBoundary : 0) +
(hasSmallExc ? METHOD_DATA_SECTION_SIZE : 0) +
(hasLargExc ? METHOD_DATA_SECTION_SIZE : 0) +
smallExcCount * 12 +
(smallExcCount / MAX_SMALL_EXC_HANDLERS_IN_ONE_SECTION) * METHOD_DATA_SECTION_SIZE + // (Amount of extra section headers ) * section size
largeExcCount * 24
];
var flags = MethodHeaderFlags.FatFormat;
if (hasAnyExc)
{
flags |= MethodHeaderFlags.MoreSections;
}
if (this._methodIL.InitLocals)
{
flags |= MethodHeaderFlags.InitLocals;
}
result.WriteInt16LEToBytes(ref resultIndex, (Int16)(((Int32)flags) | (3 << 12)))
.WriteInt16LEToBytes(ref resultIndex, (Int16)this._maxStack)
.WriteInt32LEToBytes(ref resultIndex, this._ilCodeCount)
.WriteInt32LEToBytes(ref resultIndex, this._metaData.GetSignatureTokenFor(this._method, this._methodIL._locals.ToArray()));
}
Array.Copy(this._ilCode, 0, result, resultIndex, this._ilCodeCount);
resultIndex += this._ilCodeCount;
if (hasAnyExc)
{
var processedIndices = new HashSet <Int32>();
resultIndex += amountToNext4ByteBoundary;
var flags = MethodDataFlags.ExceptionHandling;
// First, write fat sections
if (hasLargExc)
{
// TODO like with small sections, what if too many exception clauses to be fit into DataSize?
flags |= MethodDataFlags.FatFormat;
if (hasSmallExc)
{
flags |= MethodDataFlags.MoreSections;
}
result.WriteByteToBytes(ref resultIndex, (Byte)flags)
.WriteInt32LEToBytes(ref resultIndex, largeExcCount * 24 + METHOD_DATA_SECTION_SIZE);
--resultIndex;
for (var i = 0; i < exceptionBlocks.Length; ++i)
{
if (!exceptionFormats[i] && processedIndices.Add(i))
{
var length = exceptionBlocks[i].Length;
Array.Copy(exceptionBlocks[i], 0, result, resultIndex, length);
resultIndex += length;
}
}
}
// Then, write small sections
// If exception counts * 12 + 4 are > Byte.MaxValue, have to write several sections
// (Max 20 handlers per section)
flags = MethodDataFlags.ExceptionHandling;
if (hasSmallExc)
{
var curSmallIdx = 0;
while (smallExcCount > 0)
{
var amountToBeWritten = Math.Min(smallExcCount, MAX_SMALL_EXC_HANDLERS_IN_ONE_SECTION);
if (amountToBeWritten < smallExcCount)
{
flags |= MethodDataFlags.MoreSections;
}
else
{
flags = flags & ~(MethodDataFlags.MoreSections);
}
result.WriteByteToBytes(ref resultIndex, (Byte)flags)
.WriteByteToBytes(ref resultIndex, (Byte)(amountToBeWritten * 12 + METHOD_DATA_SECTION_SIZE))
.WriteInt16LEToBytes(ref resultIndex, 0);
var amountActuallyWritten = 0;
while (curSmallIdx < exceptionBlocks.Length && amountActuallyWritten < amountToBeWritten)
{
if (exceptionFormats[curSmallIdx])
{
var length = exceptionBlocks[curSmallIdx].Length;
Array.Copy(exceptionBlocks[curSmallIdx], 0, result, resultIndex, length);
resultIndex += length;
++amountActuallyWritten;
}
++curSmallIdx;
}
smallExcCount -= amountToBeWritten;
}
}
}
#if DEBUG
if (resultIndex != result.Length)
{
throw new Exception("Something went wrong when emitting method headers and body. Emitted " + resultIndex + " bytes, but was supposed to emit " + result.Length + " bytes.");
}
#endif
return(result);
}