Sc2 Paste (MD5 Lib)

//==================================================================================================
//
// Generated Map Script
//
// Name:   Blood Tournament REVIVED
//
//==================================================================================================
include "TriggerLibs/NativeLib"

//--------------------------------------------------------------------------------------------------
// Library: MD5_Hash
//--------------------------------------------------------------------------------------------------
// Function Declarations
void lib1_gf_InitializeHashInput ();
void lib1_gf_AddBooleanToHashInput (bool lp_boolean);
void lib1_gf_AddByteToHashInput (byte lp_byte);
void lib1_gf_AddBytesToHashInput (byte lp_byte, int lp_amount);
void lib1_gf_AddIntegerToHashInput (int lp_integer);
void lib1_gf_AddIntegersToHashInput (int lp_integer, int lp_amount);
void lib1_gf_AddRealToHashInput (fixed lp_real);
void lib1_gf_AddStringToHashInput (string lp_string);
void lib1_gf_AddUnitToHashInput (unit lp_unit);
string lib1_gf_GenerateMD5HashCode ();
string lib1_gf_GenerateSHA256HashCode ();

// Custom Script
//--------------------------------------------------------------------------------------------------
// Custom Script: Global Script
//--------------------------------------------------------------------------------------------------
// Copyright (C) 2011 by Danny de Jong
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
// Hash Input
byte[1024] HashInputData;
int HashInputSize = 0;
int GetHashInputLittleEndianInt( int position )
{
    int temp;
    int result;
    position *= 4;
    result = HashInputData[position];
    temp = HashInputData[position + 1];
    result |= temp << 8;
    temp = HashInputData[position + 2];
    result |= temp << 16;
    temp = HashInputData[position + 3];
    result |= temp << 24;
    return result;
}
int GetHashInputBigEndianInt( int position )
{
    int temp;
    int result;
    position *= 4;
    temp = HashInputData[position];
    result = temp << 24;
    temp = HashInputData[position + 1];
    result |= temp << 16;
    temp = HashInputData[position + 2];
    result |= temp << 8;
    temp = HashInputData[position + 3];
    result |= temp;
    return result;
}
// ASCII conversion
string asciiTable = "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff";
byte CharToAsciiCode(string charContainingString, int charPosition)
{
    return StringFind( asciiTable, StringSub( charContainingString, charPosition + 1, charPosition + 1), c_stringCase );
}
//  Hex Conversion
string[16] HexTable;
string GetHexChar( int number )
{
    return HexTable[number];
}
string GetUnsignedLittleEndianHexRepresentation( int unsignedInt )
{
    string representation = "";
    representation += GetHexChar( ( unsignedInt & 0x000000F0 ) >> 4 );
    representation += GetHexChar( ( unsignedInt & 0x0000000F ) );
    representation += GetHexChar( ( unsignedInt & 0x0000F000 ) >> 12 );
    representation += GetHexChar( ( unsignedInt & 0x00000F00) >> 8 );
    representation += GetHexChar( ( unsignedInt & 0x00F00000 ) >> 20 );
    representation += GetHexChar( ( unsignedInt & 0x000F0000) >> 16 );
    if ( unsignedInt >= 0 )
    {
        representation += GetHexChar( unsignedInt >> 28 );
    }
    else
    {
        unsignedInt += 0x7FFFFFFF + 1;
        representation += GetHexChar( 0x8 + ( unsignedInt >> 28 ) );
    }
    representation += GetHexChar( ( unsignedInt & 0x0F000000) >> 24 );
    return representation;
}
string GetUnsignedHexRepresentation( int unsignedInt )
{
    string representation = "";

    if ( unsignedInt >= 0 )
    {
        representation += GetHexChar( unsignedInt >> 28 );
    }
    else
    {
        unsignedInt += 0x7FFFFFFF + 1;
        representation += GetHexChar( 0x8 + ( unsignedInt >> 28 ) );
    }
    representation += GetHexChar( ( unsignedInt & 0x0F000000) >> 24 );
    representation += GetHexChar( ( unsignedInt & 0x00F00000 ) >> 20 );
    representation += GetHexChar( ( unsignedInt & 0x000F0000) >> 16 );
    representation += GetHexChar( ( unsignedInt & 0x0000F000 ) >> 12 );
    representation += GetHexChar( ( unsignedInt & 0x00000F00) >> 8 );
    representation += GetHexChar( ( unsignedInt & 0x000000F0 ) >> 4 );
    representation += GetHexChar( ( unsignedInt & 0x0000000F ) );
    return representation;
}
// Resolve data function
int GetFixedDataAsInt(fixed fixedVar)
{
    int data;
    data= ( FixedToInt(fixedVar) << 12 );
    fixedVar -= data;
    data|= FixedToInt( fixedVar* Pow2(12) );
    return data;
}
//  Operations
int UnsignedRightShift( int input, int shift )  // Right shift pads bit 1's when the value is under zero for signed integers. So this is the work-around.
{
    return input >> shift & ~( -1 << ( 32 - shift  ) );
}
int UnsignedLeftRotate( int input, int rotation )
{
    rotation = ModI( rotation, 32 );
    return ( input << rotation ) | UnsignedRightShift (input,  32 - rotation );
}
int UnsignedRightRotate( int input, int rotation )
{
    rotation = ModI( rotation, 32 );
    return UnsignedRightShift( input, rotation ) | ( input << ( 32 - rotation ) );
}
int UnsignedLeftRotate32( int input, int rotation ) // Optimized version for rotation within range 0 =< x =< 32
{
    return ( input << rotation ) | UnsignedRightShift (input,  32 - rotation );
}
int UnsignedRightRotate32( int input, int rotation ) // Optimized version for rotation within range 0 =< x =< 32
{
    return UnsignedRightShift( input, rotation ) | ( input << ( 32 - rotation ) );
}

//--------------------------------------------------------------------------------------------------
// Custom Script: MD5 Script
//--------------------------------------------------------------------------------------------------
// Copyright (C) 2011 by Danny de Jong
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
int Md5F( int b, int c, int d )
{
    return d ^ ( b & ( c ^ d ) );
}
int Md5G( int b, int c, int d )
{
    return c ^ ( d & ( b ^ c ) );
}
int Md5H( int b, int c, int d )
{
    return b ^ c ^ d;
}
int Md5I( int b, int c, int d )
{
    return c ^ (b | (~d));
}
int Md5FF( int a, int b, int c, int d, int w, int r, int k )
{
    return UnsignedLeftRotate32( ( a + Md5F( b, c, d ) + k + w ), r ) + b;
}
int Md5GG( int a, int b, int c, int d, int w, int r, int k )
{
    return UnsignedLeftRotate32( ( a + Md5G( b, c, d ) + k + w ), r ) + b;
}
int Md5HH( int a, int b, int c, int d, int w, int r, int k )
{
    return UnsignedLeftRotate32( ( a + Md5H( b, c, d ) + k + w ), r ) + b;
}
int Md5II( int a, int b, int c, int d, int w, int r, int k )
{
    return UnsignedLeftRotate32( ( a + Md5I( b, c, d ) + k + w ), r ) + b;
}
string GenerateMd5HashCode()
{
    //  Variables
    int h0 = 0x67452301;
    int h1 = 0x0E000000 << 4 | 0x0FCDAB89;
    int h2 = 0x09000000 << 4 | 0x08BADCFE;
    int h3 = 0x10325476;
    int a; int b; int c; int d;
    int i = 0; int j = 0;
    int messageNBits;
    int paddingLength;
    //  Prepare message
    messageNBits = HashInputSize * 8;
    HashInputData[HashInputSize] = 0x80;
    HashInputSize += 1;
    paddingLength =  56 - ModI( HashInputSize, 64 );
    if ( paddingLength < 0 )
    {
        paddingLength += 64;
    }
    while ( i < paddingLength )
    {
        HashInputData[HashInputSize] = 0;
        HashInputSize += 1;
        i += 1;
    }
    //Note: You might want to change this when the hash input increases in size.
    HashInputData[HashInputSize] = messageNBits;
    HashInputSize += 1;
    HashInputData[HashInputSize] = messageNBits >> 8;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    //  Loop
    i = 0;
    while ( i < ( HashInputSize - 1 ) )
    {
        a = h0;
        b = h1;
        c = h2;
        d = h3;
        a = Md5FF( a, b, c, d, GetHashInputLittleEndianInt( j ), 7, 0x0d000000 << 4 | 0x076aa478 );
        d = Md5FF( d, a, b, c, GetHashInputLittleEndianInt( j + 1 ), 12, 0x0e000000 << 4 | 0x08c7b756 );
        c = Md5FF( c, d, a, b, GetHashInputLittleEndianInt( j + 2 ), 17, 0x242070db );
        b = Md5FF( b, c, d, a, GetHashInputLittleEndianInt( j + 3 ), 22, 0x0c000000 << 4 | 0x01bdceee );
        a = Md5FF( a, b, c, d, GetHashInputLittleEndianInt( j + 4 ), 7, 0x0f000000 << 4 | 0x057c0faf );
        d = Md5FF( d, a, b, c, GetHashInputLittleEndianInt( j + 5 ), 12, 0x4787c62a );
        c = Md5FF( c, d, a, b, GetHashInputLittleEndianInt( j + 6 ), 17, 0x0a000000 << 4 | 0x08304613 );
        b = Md5FF( b, c, d, a, GetHashInputLittleEndianInt( j + 7 ), 22, 0x0f000000 << 4 | 0x0d469501 );
        a = Md5FF( a, b, c, d, GetHashInputLittleEndianInt( j + 8 ), 7, 0x698098d8 );
        d = Md5FF( d, a, b, c, GetHashInputLittleEndianInt( j + 9 ), 12, 0x08000000 << 4 | 0x0b44f7af );
        c = Md5FF( c, d, a, b, GetHashInputLittleEndianInt( j + 10 ), 17, 0x0f000000 << 4 | 0x0fff5bb1 );
        b = Md5FF( b, c, d, a, GetHashInputLittleEndianInt( j + 11 ), 22, 0x08000000 << 4 | 0x095cd7be );
        a = Md5FF( a, b, c, d, GetHashInputLittleEndianInt( j + 12 ), 7, 0x6b901122 );
        d = Md5FF( d, a, b, c, GetHashInputLittleEndianInt( j + 13 ), 12, 0x0f000000 << 4 | 0x0d987193 );
        c = Md5FF( c, d, a, b, GetHashInputLittleEndianInt( j+ 14 ), 17, 0x0a000000 << 4 | 0x0679438e );
        b = Md5FF( b, c, d, a, GetHashInputLittleEndianInt( j + 15 ), 22, 0x49b40821 );
        a = Md5GG( a, b, c, d, GetHashInputLittleEndianInt( j + 1 ), 5, 0x0f000000 << 4 | 0x061e2562 );
        d = Md5GG( d, a, b, c, GetHashInputLittleEndianInt( j + 6 ), 9, 0x0c000000 << 4 | 0x0040b340 );
        c = Md5GG( c, d, a, b, GetHashInputLittleEndianInt( j + 11 ), 14, 0x265e5a51 );
        b = Md5GG( b, c, d, a, GetHashInputLittleEndianInt( j ), 20, 0x0e000000 << 4 | 0x09b6c7aa );
        a = Md5GG( a, b, c, d, GetHashInputLittleEndianInt( j + 5 ), 5, 0x0d000000 << 4 | 0x062f105d );
        d = Md5GG( d, a, b, c, GetHashInputLittleEndianInt( j + 10 ), 9, 0x02441453 );
        c = Md5GG( c, d, a, b, GetHashInputLittleEndianInt( j + 15 ), 14, 0x0d000000 << 4 | 0x08a1e681 );
        b = Md5GG( b, c, d, a, GetHashInputLittleEndianInt( j + 4 ), 20, 0x0e000000 << 4 | 0x07d3fbc8 );
        a = Md5GG( a, b, c, d, GetHashInputLittleEndianInt( j + 9 ), 5, 0x21e1cde6 );
        d = Md5GG( d, a, b, c, GetHashInputLittleEndianInt( j + 14 ), 9, 0x0c000000 << 4 | 0x033707d6 );
        c = Md5GG( c, d, a, b, GetHashInputLittleEndianInt( j + 3 ), 14, 0x0f000000 << 4 | 0x04d50d87 );
        b = Md5GG( b, c, d, a, GetHashInputLittleEndianInt( j + 8 ), 20, 0x455a14ed );
        a = Md5GG( a, b, c, d, GetHashInputLittleEndianInt( j + 13 ), 5, 0x0a000000 << 4 | 0x09e3e905 );
        d = Md5GG( d, a, b, c, GetHashInputLittleEndianInt( j + 2 ), 9, 0x0f000000 << 4 | 0x0cefa3f8 );
        c = Md5GG( c, d, a, b, GetHashInputLittleEndianInt( j + 7 ), 14,  0x676f02d9 );
        b = Md5GG( b, c, d, a, GetHashInputLittleEndianInt( j + 12 ), 20, 0x08000000 << 4 | 0x0d2a4c8a );
        a = Md5HH( a, b, c, d, GetHashInputLittleEndianInt( j + 5 ), 4, 0x0f000000 << 4 | 0x0ffa3942 );
        d = Md5HH( d, a, b, c, GetHashInputLittleEndianInt( j + 8 ), 11, 0x08000000 << 4 | 0x0771f681 );
        c = Md5HH( c, d, a, b, GetHashInputLittleEndianInt( j + 11 ), 16, 0x6d9d6122 );
        b = Md5HH( b, c, d, a, GetHashInputLittleEndianInt( j + 14 ), 23, 0x0f000000 << 4 | 0x0de5380c );
        a = Md5HH( a, b, c, d, GetHashInputLittleEndianInt( j + 1 ), 4, 0x0a000000 << 4 | 0x04beea44 );
        d = Md5HH( d, a, b, c, GetHashInputLittleEndianInt( j + 4 ), 11, 0x4bdecfa9 );
        c = Md5HH( c, d, a, b, GetHashInputLittleEndianInt( j + 7 ), 16, 0x0f000000 << 4 | 0x06bb4b60 );
        b = Md5HH( b, c, d, a, GetHashInputLittleEndianInt( j + 10 ), 23, 0x0b000000 << 4 | 0x0ebfbc70 );
        a = Md5HH( a, b, c, d, GetHashInputLittleEndianInt( j + 13 ), 4, 0x289b7ec6 );
        d = Md5HH( d, a, b, c, GetHashInputLittleEndianInt( j + 0 ), 11, 0x0e000000 << 4 | 0x0aa127fa );
        c = Md5HH( c, d, a, b, GetHashInputLittleEndianInt( j + 3 ), 16, 0x0d000000 << 4 | 0x04ef3085 );
        b = Md5HH( b, c, d, a, GetHashInputLittleEndianInt( j + 6 ), 23, 0x04881d05 );
        a = Md5HH( a, b, c, d, GetHashInputLittleEndianInt( j + 9 ), 4, 0x0d000000 << 4 | 0x09d4d039 );
        d = Md5HH( d, a, b, c, GetHashInputLittleEndianInt( j + 12 ), 11, 0x0e000000 << 4 | 0x06db99e5 );
        c = Md5HH( c, d, a, b, GetHashInputLittleEndianInt( j + 15 ), 16, 0x1fa27cf8 );
        b = Md5HH( b, c, d, a, GetHashInputLittleEndianInt( j + 2 ), 23, 0x0c000000 << 4 | 0x04ac5665 );
        a = Md5II( a, b, c, d, GetHashInputLittleEndianInt( j ), 6, 0x0f000000 << 4 | 0x04292244 );
        d = Md5II( d, a, b, c, GetHashInputLittleEndianInt( j + 7 ), 10, 0x432aff97 );
        c = Md5II( c, d, a, b, GetHashInputLittleEndianInt( j + 14 ), 15, 0x0a000000 << 4 | 0x0b9423a7 );
        b = Md5II( b, c, d, a, GetHashInputLittleEndianInt( j + 5 ), 21, 0x0f000000 << 4 | 0x0c93a039 );
        a = Md5II( a, b, c, d, GetHashInputLittleEndianInt( j + 12 ), 6, 0x655b59c3 );
        d = Md5II( d, a, b, c, GetHashInputLittleEndianInt( j + 3 ), 10, 0x08000000 << 4 | 0x0f0ccc92 );
        c = Md5II( c, d, a, b, GetHashInputLittleEndianInt( j + 10 ), 15, 0x0f000000 << 4 | 0x0feff47d );
        b = Md5II( b, c, d, a, GetHashInputLittleEndianInt( j + 1 ), 21, 0x08000000 << 4 | 0x05845dd1 );
        a = Md5II( a, b, c, d, GetHashInputLittleEndianInt( j + 8 ), 6, 0x6fa87e4f );
        d = Md5II( d, a, b, c, GetHashInputLittleEndianInt( j + 15 ), 10, 0x0f000000 << 4 | 0x0e2ce6e0 );
        c = Md5II( c, d, a, b, GetHashInputLittleEndianInt( j + 6 ), 15, 0x0a000000 << 4 | 0x03014314 );
        b = Md5II( b, c, d, a, GetHashInputLittleEndianInt( j + 13 ), 21, 0x4e0811a1 );
        a = Md5II( a, b, c, d, GetHashInputLittleEndianInt( j + 4 ), 6, 0x0f000000 << 4 | 0x07537e82 );
        d = Md5II( d, a, b, c, GetHashInputLittleEndianInt( j + 11 ), 10, 0x0b000000 << 4 | 0x0d3af235 );
        c = Md5II( c, d, a, b, GetHashInputLittleEndianInt( j + 2 ), 15, 0x2ad7d2bb );
        b = Md5II( b, c, d, a, GetHashInputLittleEndianInt( j + 9 ), 21, 0x0e000000 << 4 | 0x0b86d391 );
        h0 += a;
        h1 += b;
        h2 += c;
        h3 += d;
        i += 64;
        j += 16;
    }

    return GetUnsignedLittleEndianHexRepresentation( h0 ) + GetUnsignedLittleEndianHexRepresentation( h1 ) + GetUnsignedLittleEndianHexRepresentation( h2 ) + GetUnsignedLittleEndianHexRepresentation( h3 );
}

//--------------------------------------------------------------------------------------------------
// Custom Script: SHA256 Script
//--------------------------------------------------------------------------------------------------
// Copyright (C) 2011 by Danny de Jong
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
int Sha256Ch( int x, int y, int z )
{
    return ( x & y ) ^ ( ~x & z );
}
int Sha256Maj( int x, int y, int z )
{
    return ( x & y ) ^ ( x & z ) ^ ( y & z );
}
int Sha256CapitalSigma0( int x )
{
    return UnsignedRightRotate32( x, 2 ) ^ UnsignedRightRotate32( x, 13 ) ^ UnsignedRightRotate32( x, 22 );
}
int Sha256CapitalSigma1( int x )
{
    return UnsignedRightRotate32( x, 6 ) ^ UnsignedRightRotate32( x, 11 ) ^ UnsignedRightRotate32( x, 25 );
}
int Sha256Sigma0( int x )
{
    return UnsignedRightRotate32( x, 7 ) ^ UnsignedRightRotate32( x, 18 ) ^ UnsignedRightShift( x, 3 );
}
int Sha256Sigma1( int x )
{
    return UnsignedRightRotate32( x, 17 ) ^ UnsignedRightRotate32( x, 19 ) ^ UnsignedRightShift( x, 10 );
}
int Sha256T0( int e, int f, int g, int h, int k, int w )
{
    return h + Sha256CapitalSigma1( e ) + Sha256Ch( e, f, g ) + k + w;
}
int Sha256T1( int a, int b, int c )
{
    return Sha256CapitalSigma0( a ) + Sha256Maj( a, b, c );
}
string GenerateSha256HashCode()
{
    //  Variables
    int h0 = 0x6a09e667;
    int h1 = 0x0b000000 << 4 | 0x0b67ae85;
    int h2 = 0x3c6ef372;
    int h3 = 0x0a000000 << 4 | 0x054ff53a;
    int h4 = 0x510e527f;
    int h5 = 0x09000000 << 4 | 0x0b05688c;
    int h6 = 0x1f83d9ab;
    int h7 = 0x5be0cd19;
    int a; int b; int c; int d; int e; int f; int g; int h; int t0; int t1;
    int[64] w;
    int i = 0; int j = 0; int k = 0;
    int messageNBits;
    int paddingLength;
    //  Prepare message
    messageNBits = HashInputSize * 8;
    HashInputData[HashInputSize] = 0x80;
    HashInputSize += 1;
    paddingLength =  56 - ModI( HashInputSize, 64 );
    if ( paddingLength < 0 )
    {
        paddingLength += 64;
    }
    while ( i < paddingLength )
    {
        HashInputData[HashInputSize] = 0;
        HashInputSize += 1;
        i += 1;
    }
    //Note: You might want to change this when the hash input increases in size.
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = 0;
    HashInputSize += 1;
    HashInputData[HashInputSize] = messageNBits >> 8;
    HashInputSize += 1;
    HashInputData[HashInputSize] = messageNBits;
    HashInputSize += 1;
    //  Loop
    i = 0;
    while ( i < ( HashInputSize - 1 ) )
    {
        //  Working Variables
        a = h0;
        b = h1;
        c = h2;
        d = h3;
        e = h4;
        f = h5;
        g = h6;
        h = h7;
        //  Preparing Extra Message Schedule
        j = 0;
        while ( j < 16 )
        {
            w[j] = GetHashInputBigEndianInt( k );
            j += 1;
            k += 1;
        }
        while ( j < 64 )
        {
            w[j] =  Sha256Sigma1( w[j - 2] ) +
            w[j - 7] +
            Sha256Sigma0( w[j - 15] ) +
            w[j - 16];

            j += 1;
        }
        // 0 to 15
        t0 = Sha256T0( e, f, g, h, 0x428a2f98, w[0] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0; i += 1;
        t0 = Sha256T0( d, e, f, g, 0x71374491, w[1] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0; i += 1;
        t0 = Sha256T0( c, d, e, f, 0x0b000000 << 4 | 0x05c0fbcf, w[2] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0; i += 1;
        t0 = Sha256T0( b, c, d, e, 0x0e000000 << 4 | 0x09b5dba5, w[3] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0; i += 1;
        t0 = Sha256T0( a, b, c, d, 0x3956c25b, w[4] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0; i += 1;
        t0 = Sha256T0( h, a, b, c, 0x59f111f1, w[5] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0; i += 1;
        t0 = Sha256T0( g, h, a, b, 0x09000000 << 4 | 0x023f82a4, w[6] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0; i += 1;
        t0 = Sha256T0( f, g, h, a, 0x0a000000 << 4 | 0x0b1c5ed5, w[7] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0; i += 1;
        t0 = Sha256T0( e, f, g, h, 0x0d000000 << 4 | 0x0807aa98, w[8] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0; i += 1;
        t0 = Sha256T0( d, e, f, g, 0x12835b01, w[9] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0; i += 1;
        t0 = Sha256T0( c, d, e, f, 0x243185be, w[10] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0; i += 1;
        t0 = Sha256T0( b, c, d, e, 0x550c7dc3, w[11] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0; i += 1;
        t0 = Sha256T0( a, b, c, d, 0x72be5d74, w[12] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0; i += 1;
        t0 = Sha256T0( h, a, b, c, 0x08000000 << 4 | 0x00deb1fe, w[13] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0; i += 1;
        t0 = Sha256T0( g, h, a, b, 0x09000000 << 4 | 0x0bdc06a7, w[14] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0; i += 1;
        t0 = Sha256T0( f, g, h, a, 0x0c000000 << 4 | 0x019bf174, w[15] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0;
        // 16 to 31
        t0 = Sha256T0( e, f, g, h, 0x0e000000 << 4 | 0x049b69c1, w[16] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0;
        t0 = Sha256T0( d, e, f, g, 0x0e000000 << 4 | 0x0fbe4786, w[17] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0;
        t0 = Sha256T0( c, d, e, f, 0x0fc19dc6, w[18] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0;
        t0 = Sha256T0( b, c, d, e, 0x240ca1cc, w[19] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0;
        t0 = Sha256T0( a, b, c, d, 0x2de92c6f, w[20] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0;
        t0 = Sha256T0( h, a, b, c, 0x4a7484aa, w[21] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0;
        t0 = Sha256T0( g, h, a, b, 0x5cb0a9dc, w[22] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0;
        t0 = Sha256T0( f, g, h, a, 0x76f988da, w[23] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0;
        t0 = Sha256T0( e, f, g, h, 0x09000000 << 4 | 0x083e5152, w[24] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0;
        t0 = Sha256T0( d, e, f, g, 0x0a000000 << 4 | 0x0831c66d, w[25] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0;
        t0 = Sha256T0( c, d, e, f, 0x0b000000 << 4 | 0x000327c8, w[26] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0;
        t0 = Sha256T0( b, c, d, e, 0x0b000000 << 4 | 0x0f597fc7, w[27] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0;
        t0 = Sha256T0( a, b, c, d, 0x0c000000 << 4 | 0x06e00bf3, w[28] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0;
        t0 = Sha256T0( h, a, b, c, 0x0d000000 << 4 | 0x05a79147, w[29] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0;
        t0 = Sha256T0( g, h, a, b, 0x06ca6351, w[30] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0;
        t0 = Sha256T0( f, g, h, a, 0x14292967, w[31] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0;
        // 32 to 47
        t0 = Sha256T0( e, f, g, h, 0x27b70a85, w[32] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0;
        t0 = Sha256T0( d, e, f, g, 0x2e1b2138, w[33] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0;
        t0 = Sha256T0( c, d, e, f, 0x4d2c6dfc, w[34] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0;
        t0 = Sha256T0( b, c, d, e, 0x53380d13, w[35] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0;
        t0 = Sha256T0( a, b, c, d, 0x650a7354, w[36] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0;
        t0 = Sha256T0( h, a, b, c, 0x766a0abb, w[37] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0;
        t0 = Sha256T0( g, h, a, b, 0x08000000 << 4 | 0x01c2c92e, w[38] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0;
        t0 = Sha256T0( f, g, h, a, 0x09000000 << 4 | 0x02722c85, w[39] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0;
        t0 = Sha256T0( e, f, g, h, 0x0a000000 << 4 | 0x02bfe8a1, w[40] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0;
        t0 = Sha256T0( d, e, f, g, 0x0a000000 << 4 | 0x081a664b, w[41] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0;
        t0 = Sha256T0( c, d, e, f, 0x0c000000 << 4 | 0x024b8b70, w[42] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0;
        t0 = Sha256T0( b, c, d, e, 0x0c000000 << 4 | 0x076c51a3, w[43] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0;
        t0 = Sha256T0( a, b, c, d, 0x0d000000 << 4 | 0x0192e819, w[44] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0;
        t0 = Sha256T0( h, a, b, c, 0x0d000000 << 4 | 0x06990624, w[45] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0;
        t0 = Sha256T0( g, h, a, b, 0x0f000000 << 4 | 0x040e3585, w[46] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0;
        t0 = Sha256T0( f, g, h, a, 0x106aa070, w[47] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0;
        // 48 to 63
        t0 = Sha256T0( e, f, g, h, 0x19a4c116, w[48] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0;
        t0 = Sha256T0( d, e, f, g, 0x1e376c08, w[49] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0;
        t0 = Sha256T0( c, d, e, f, 0x2748774c, w[50] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0;
        t0 = Sha256T0( b, c, d, e, 0x34b0bcb5, w[51] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0;
        t0 = Sha256T0( a, b, c, d, 0x391c0cb3, w[52] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0;
        t0 = Sha256T0( h, a, b, c, 0x4ed8aa4a, w[53] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0;
        t0 = Sha256T0( g, h, a, b, 0x5b9cca4f, w[54] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0;
        t0 = Sha256T0( f, g, h, a, 0x682e6ff3, w[55] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0;
        t0 = Sha256T0( e, f, g, h, 0x748f82ee, w[56] ); t1 = Sha256T1( a, b, c );
        h = t0 + t1; d += t0;
        t0 = Sha256T0( d, e, f, g, 0x78a5636f, w[57] ); t1 = Sha256T1( h, a, b );
        g = t0 + t1; c += t0;
        t0 = Sha256T0( c, d, e, f, 0x08000000 << 4 | 0x04c87814, w[58] ); t1 = Sha256T1( g, h, a );
        f = t0 + t1; b += t0;
        t0 = Sha256T0( b, c, d, e, 0x08000000 << 4 | 0x0cc70208, w[59] ); t1 = Sha256T1( f, g, h );
        e = t0 + t1; a += t0;
        t0 = Sha256T0( a, b, c, d, 0x09000000 << 4 | 0x00befffa, w[60] ); t1 = Sha256T1( e, f, g );
        d = t0 + t1; h += t0;
        t0 = Sha256T0( h, a, b, c, 0x0a000000 << 4 | 0x04506ceb, w[61] ); t1 = Sha256T1( d, e, f );
        c = t0 + t1; g += t0;
        t0 = Sha256T0( g, h, a, b, 0x0b000000 << 4 | 0x0ef9a3f7, w[62] ); t1 = Sha256T1( c, d, e );
        b = t0 + t1; f += t0;
        t0 = Sha256T0( f, g, h, a, 0x0c000000 << 4 | 0x067178f2, w[63] ); t1 = Sha256T1( b, c, d );
        a = t0 + t1; e += t0;
        h0 += a;
        h1 += b;
        h2 += c;
        h3 += d;
        h4 += e;
        h5 += f;
        h6 += g;
        h7 += h;
        i += 49;
    }
    return  GetUnsignedHexRepresentation(h0) +
            GetUnsignedHexRepresentation(h1) +
            GetUnsignedHexRepresentation(h2) +
            GetUnsignedHexRepresentation(h3) +
            GetUnsignedHexRepresentation(h4) +
            GetUnsignedHexRepresentation(h5) +
            GetUnsignedHexRepresentation(h6) +
            GetUnsignedHexRepresentation(h7);
}

void lib1_InitCustomScript () {
}

// Functions
void lib1_gf_InitializeHashInput () {
    // Variable Declarations
    string lv_emptyString;

    // Variable Initialization
    lv_emptyString = "";

    // Implementation
    HashInputSize = 0;
    if ( HexTable[0] == "" )
    {
        HexTable[0] = "0"; HexTable[1] = "1"; HexTable[2] = "2"; HexTable[3] = "3";
        HexTable[4] = "4"; HexTable[5] = "5"; HexTable[6] = "6"; HexTable[7] = "7";
        HexTable[8] = "8"; HexTable[9] = "9"; HexTable[10] = "a"; HexTable[11] = "b";
        HexTable[12] = "c"; HexTable[13] = "d"; HexTable[14] = "e"; HexTable[15] = "f";
    }
}

void lib1_gf_AddBooleanToHashInput (bool lp_boolean) {
    // Implementation
    lib1_gf_AddByteToHashInput(BoolToInt( lp_boolean ));
}

void lib1_gf_AddByteToHashInput (byte lp_byte) {
    // Implementation
    HashInputData[HashInputSize] = lp_byte;
    HashInputSize += 1;
}

void lib1_gf_AddBytesToHashInput (byte lp_byte, int lp_amount) {
    // Implementation
    IntLoopBegin(1, lp_amount);
    for ( ; !IntLoopDone() ; IntLoopStep() ) {
        lib1_gf_AddByteToHashInput(lp_byte);
    }
    IntLoopEnd();
}

void lib1_gf_AddIntegerToHashInput (int lp_integer) {
    // Implementation
    lib1_gf_AddByteToHashInput(lp_integer);
    lib1_gf_AddByteToHashInput(lp_integer >> 8);
    lib1_gf_AddByteToHashInput(lp_integer >> 16);
    lib1_gf_AddByteToHashInput(lp_integer >> 24);
}

void lib1_gf_AddIntegersToHashInput (int lp_integer, int lp_amount) {
    // Implementation
    IntLoopBegin(1, lp_amount);
    for ( ; !IntLoopDone() ; IntLoopStep() ) {
        lib1_gf_AddIntegerToHashInput(lp_integer);
    }
    IntLoopEnd();
}

void lib1_gf_AddRealToHashInput (fixed lp_real) {
    // Implementation
    lib1_gf_AddIntegerToHashInput(GetFixedDataAsInt( lp_real ));
}

void lib1_gf_AddStringToHashInput (string lp_string) {
    // Implementation
    IntLoopBegin(0, (StringLength(lp_string) - 1));
    for ( ; !IntLoopDone() ; IntLoopStep() ) {
        lib1_gf_AddByteToHashInput(CharToAsciiCode( lp_string, IntLoopCurrent() ));
    }
    IntLoopEnd();
}

void lib1_gf_AddUnitToHashInput (unit lp_unit) {
    // Implementation
    lib1_gf_AddStringToHashInput((UnitGetType(lp_unit)));
    lib1_gf_AddRealToHashInput(UnitGetPropertyFixed(lp_unit, c_unitPropLife, c_unitPropCurrent));
    lib1_gf_AddRealToHashInput(UnitGetPropertyFixed(lp_unit, c_unitPropShields, c_unitPropCurrent));
    lib1_gf_AddRealToHashInput(UnitGetPropertyFixed(lp_unit, c_unitPropEnergy, c_unitPropCurrent));
}

string lib1_gf_GenerateMD5HashCode () {
    // Implementation
    return GenerateMd5HashCode();
}

string lib1_gf_GenerateSHA256HashCode () {
    // Implementation
    return GenerateSha256HashCode();
}

//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
bool lib1_InitLib_completed = false;

void lib1_InitLib () {
    if (lib1_InitLib_completed) {
        return;
    }

    lib1_InitCustomScript();

    lib1_InitLib_completed = true;
}

//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
void InitLibs () {
    libNtve_InitLib();
    lib1_InitLib();
}

//--------------------------------------------------------------------------------------------------
// Constants
//--------------------------------------------------------------------------------------------------
const string gv_bank_code = "IKXEX ONAFS IYRNC LYILD HQSBO YDSMI SKPKP IFZEE CRN";

//--------------------------------------------------------------------------------------------------
// Global Variables
//--------------------------------------------------------------------------------------------------
int[9] gv_bonusRoundScore;
int gv_bonusRoundPlayer;
bank[9] gv_bank;
int[9] gv_bank_kills;
int[9] gv_bank_wins;
int[9] gv_bank_loses;
string[9] gv_bank_wins_sec;
string[9] gv_bank_loses_sec;
string[9] gv_bank_kills_sec;
int gv_unstucks;
bool[9] gv_playerunstucks;
string gv_texttotypein;
int gv_banktoreset;
int gv_invocer;
bool[9] gv_betatester;
int gv_nC3A4chsteRunde;
int[16] gv_kills;
string[16] gv_kills_string;
int gv_killDialogfenster;
int[9] gv_killDialoggegenstand;
int gv_timerWindow;
timer gv_timer;

void InitGlobals () {
    int init_i;

    gv_bonusRoundPlayer = 1;
    for (init_i = 0; init_i <= 8; init_i += 1) {
        gv_bank_wins_sec[init_i] = "";
    }
    for (init_i = 0; init_i <= 8; init_i += 1) {
        gv_bank_loses_sec[init_i] = "";
    }
    for (init_i = 0; init_i <= 8; init_i += 1) {
        gv_bank_kills_sec[init_i] = "";
    }
    gv_texttotypein = "";
    for (init_i = 0; init_i <= 15; init_i += 1) {
        gv_kills_string[init_i] = "";
    }
    gv_killDialogfenster = c_invalidDialogId;
    for (init_i = 0; init_i <= 8; init_i += 1) {
        gv_killDialoggegenstand[init_i] = c_invalidDialogControlId;
    }
    gv_timerWindow = c_timerWindowNone;
    gv_timer = TimerCreate();
}

//--------------------------------------------------------------------------------------------------
// Global Function Declarations
//--------------------------------------------------------------------------------------------------
void gf_CopyRightBot (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyLeftBot (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyRightTop (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyLeftTop (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyRotateBotRight (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyRotateTopLeft (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyRotateTopRight (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyRotateBotLeft (int lp_player, point lp_punkt1, point lp_punkt2);
bool gf_BonusRoundDead (int lp_player);
int gf_getlivingplayers ();
void gf_startTimer (int lp_time, int lp_round);
void gf_CopyMidLeft (int lp_player, point lp_punkt1, point lp_punkt2);
void gf_CopyMidRight (int lp_player, point lp_punkt1, point lp_punkt2);

//--------------------------------------------------------------------------------------------------
// Trigger Variables
//--------------------------------------------------------------------------------------------------
trigger gt_T1Dies;
trigger gt_T2Dies;
trigger gt_T3Dies;
trigger gt_T4Dies;
trigger gt_T5Dies;
trigger gt_Midcleanup;
trigger gt_UnitinBonusrounddies;
trigger gt_BonusRound1akaRound5;
trigger gt_BonusRound2akaRound9;
trigger gt_QuarterFinal;
trigger gt_SemiFinal;
trigger gt_Final;
trigger gt_KillPylo;
trigger gt_Vor1;
trigger gt_Round1;
trigger gt_Round2;
trigger gt_Round3;
trigger gt_Round4;
trigger gt_Round6;
trigger gt_Round7;
trigger gt_Round8;
trigger gt_Killall;
trigger gt_AntiIdle;
trigger gt_UnitInMiddledies;
trigger gt_CreateBank;
trigger gt_SaveBanks;
trigger gt_getAlivePlayers;
trigger gt_testtextpos;
trigger gt_Unstuck;
trigger gt_beta;
trigger gt_code;
trigger gt_give;
trigger gt_kick;
trigger gt_resetBank;
trigger gt_shure;
trigger gt_id;
trigger gt_CreateDialog;
trigger gt_DestroyDialog;
trigger gt_GlobalIni;
trigger gt_AntiMoveafterBuild;
trigger gt_KillNoob;
trigger gt_AntiMoveafterWavestart;
trigger gt_BanditCrit;
trigger gt_KnightDmgReduce;

//--------------------------------------------------------------------------------------------------
// Global Functions
//--------------------------------------------------------------------------------------------------
void gf_CopyRightBot (int lp_player, point lp_punkt1, point lp_punkt2) {
    int autoE2DFC705_ae;
    int autoE2DFC705_ai;
    int autoB46B2889_ae;
    int autoB46B2889_ai;

    // Variable Declarations
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    autoE2DFC705_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoE2DFC705_ai = 1;
    lv_i = 1;
    for ( ; ( (autoE2DFC705_ai >= 0 && lv_i <= autoE2DFC705_ae) || (autoE2DFC705_ai <= 0 && lv_i >= autoE2DFC705_ae) ) ; lv_i += autoE2DFC705_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    autoB46B2889_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoB46B2889_ai = 1;
    lv_i = 1;
    for ( ; ( (autoB46B2889_ai >= 0 && lv_i <= autoB46B2889_ae) || (autoB46B2889_ai <= 0 && lv_i >= autoB46B2889_ae) ) ; lv_i += autoB46B2889_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) + lv_dy[lv_i]), (PointGetY(lp_punkt2) + lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
}

void gf_CopyLeftBot (int lp_player, point lp_punkt1, point lp_punkt2) {
    int autoD8F798D6_ae;
    int autoD8F798D6_ai;
    int auto86949202_ae;
    int auto86949202_ai;

    // Variable Declarations
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    autoD8F798D6_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoD8F798D6_ai = 1;
    lv_i = 1;
    for ( ; ( (autoD8F798D6_ai >= 0 && lv_i <= autoD8F798D6_ae) || (autoD8F798D6_ai <= 0 && lv_i >= autoD8F798D6_ae) ) ; lv_i += autoD8F798D6_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    auto86949202_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto86949202_ai = 1;
    lv_i = 1;
    for ( ; ( (auto86949202_ai >= 0 && lv_i <= auto86949202_ae) || (auto86949202_ai <= 0 && lv_i >= auto86949202_ae) ) ; lv_i += auto86949202_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) - lv_dy[lv_i]), (PointGetY(lp_punkt2) + lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
}

void gf_CopyRightTop (int lp_player, point lp_punkt1, point lp_punkt2) {
    int auto93688349_ae;
    int auto93688349_ai;
    int auto92C74250_ae;
    int auto92C74250_ai;

    // Variable Declarations
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto93688349_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto93688349_ai = 1;
    lv_i = 1;
    for ( ; ( (auto93688349_ai >= 0 && lv_i <= auto93688349_ae) || (auto93688349_ai <= 0 && lv_i >= auto93688349_ae) ) ; lv_i += auto93688349_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    auto92C74250_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto92C74250_ai = 1;
    lv_i = 1;
    for ( ; ( (auto92C74250_ai >= 0 && lv_i <= auto92C74250_ae) || (auto92C74250_ai <= 0 && lv_i >= auto92C74250_ae) ) ; lv_i += auto92C74250_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) + lv_dy[lv_i]), (PointGetY(lp_punkt2) - lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
}

void gf_CopyLeftTop (int lp_player, point lp_punkt1, point lp_punkt2) {
    int auto78B873D3_ae;
    int auto78B873D3_ai;
    int autoC1576191_ae;
    int autoC1576191_ai;

    // Variable Declarations
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto78B873D3_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto78B873D3_ai = 1;
    lv_i = 1;
    for ( ; ( (auto78B873D3_ai >= 0 && lv_i <= auto78B873D3_ae) || (auto78B873D3_ai <= 0 && lv_i >= auto78B873D3_ae) ) ; lv_i += auto78B873D3_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    autoC1576191_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoC1576191_ai = 1;
    lv_i = 1;
    for ( ; ( (autoC1576191_ai >= 0 && lv_i <= autoC1576191_ae) || (autoC1576191_ai <= 0 && lv_i >= autoC1576191_ae) ) ; lv_i += autoC1576191_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) - lv_dy[lv_i]), (PointGetY(lp_punkt2) - lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
}

void gf_CopyRotateBotRight (int lp_player, point lp_punkt1, point lp_punkt2) {
    int auto6BF02EE8_ae;
    int auto6BF02EE8_ai;
    int autoEE6ED23A_ae;
    int autoEE6ED23A_ai;
    int autoD69A111D_ae;
    int autoD69A111D_ai;
    int auto090A8C61_ae;
    int auto090A8C61_ai;
    int autoD507034A_ae;
    int autoD507034A_ai;

    // Variable Declarations
    unitgroup lv_cleanupgroup;
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_cleanupgroup = UnitGroupEmpty();
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto6BF02EE8_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto6BF02EE8_ai = 1;
    lv_i = 1;
    for ( ; ( (auto6BF02EE8_ai >= 0 && lv_i <= auto6BF02EE8_ae) || (auto6BF02EE8_ai <= 0 && lv_i >= auto6BF02EE8_ae) ) ; lv_i += auto6BF02EE8_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    autoEE6ED23A_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoEE6ED23A_ai = 1;
    lv_i = 1;
    for ( ; ( (autoEE6ED23A_ai >= 0 && lv_i <= autoEE6ED23A_ae) || (autoEE6ED23A_ai <= 0 && lv_i >= autoEE6ED23A_ae) ) ; lv_i += autoEE6ED23A_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(PointFromId(32)) - lv_dy[lv_i]), (PointGetY(PointFromId(32)) - lv_dx[lv_i])), 270.0);
    }
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    lv_i = 0;
    autoD69A111D_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoD69A111D_ai = 1;
    lv_i = 1;
    for ( ; ( (autoD69A111D_ai >= 0 && lv_i <= autoD69A111D_ae) || (autoD69A111D_ai <= 0 && lv_i >= autoD69A111D_ae) ) ; lv_i += autoD69A111D_ai ) {
        lv_unitname[lv_i] = null;
        lv_dy[lv_i] = 0.0;
        lv_dx[lv_i] = 0.0;
    }
    auto090A8C61_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto090A8C61_ai = 1;
    lv_i = 1;
    for ( ; ( (auto090A8C61_ai >= 0 && lv_i <= auto090A8C61_ae) || (auto090A8C61_ai <= 0 && lv_i >= auto090A8C61_ae) ) ; lv_i += auto090A8C61_ai ) {
        lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
        lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
        lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
    }
    autoD507034A_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoD507034A_ai = 1;
    lv_i = 1;
    for ( ; ( (autoD507034A_ai >= 0 && lv_i <= autoD507034A_ae) || (autoD507034A_ai <= 0 && lv_i >= autoD507034A_ae) ) ; lv_i += autoD507034A_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) + lv_dy[lv_i]), (PointGetY(lp_punkt2) + lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
    lv_cleanupgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupLoopBegin(lv_cleanupgroup);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitKill(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
}

void gf_CopyRotateTopLeft (int lp_player, point lp_punkt1, point lp_punkt2) {
    int auto32B3567F_ae;
    int auto32B3567F_ai;
    int auto0009CF3C_ae;
    int auto0009CF3C_ai;
    int auto7C8B3F12_ae;
    int auto7C8B3F12_ai;
    int auto3A3D76A8_ae;
    int auto3A3D76A8_ai;
    int autoBC075FDB_ae;
    int autoBC075FDB_ai;

    // Variable Declarations
    unitgroup lv_cleanupgroup;
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_cleanupgroup = UnitGroupEmpty();
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto32B3567F_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto32B3567F_ai = 1;
    lv_i = 1;
    for ( ; ( (auto32B3567F_ai >= 0 && lv_i <= auto32B3567F_ae) || (auto32B3567F_ai <= 0 && lv_i >= auto32B3567F_ae) ) ; lv_i += auto32B3567F_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    auto0009CF3C_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto0009CF3C_ai = 1;
    lv_i = 1;
    for ( ; ( (auto0009CF3C_ai >= 0 && lv_i <= auto0009CF3C_ae) || (auto0009CF3C_ai <= 0 && lv_i >= auto0009CF3C_ae) ) ; lv_i += auto0009CF3C_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(PointFromId(32)) - lv_dy[lv_i]), (PointGetY(PointFromId(32)) - lv_dx[lv_i])), 270.0);
    }
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    lv_i = 0;
    auto7C8B3F12_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto7C8B3F12_ai = 1;
    lv_i = 1;
    for ( ; ( (auto7C8B3F12_ai >= 0 && lv_i <= auto7C8B3F12_ae) || (auto7C8B3F12_ai <= 0 && lv_i >= auto7C8B3F12_ae) ) ; lv_i += auto7C8B3F12_ai ) {
        lv_unitname[lv_i] = null;
        lv_dy[lv_i] = 0.0;
        lv_dx[lv_i] = 0.0;
    }
    auto3A3D76A8_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto3A3D76A8_ai = 1;
    lv_i = 1;
    for ( ; ( (auto3A3D76A8_ai >= 0 && lv_i <= auto3A3D76A8_ae) || (auto3A3D76A8_ai <= 0 && lv_i >= auto3A3D76A8_ae) ) ; lv_i += auto3A3D76A8_ai ) {
        lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
        lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
        lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
    }
    autoBC075FDB_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoBC075FDB_ai = 1;
    lv_i = 1;
    for ( ; ( (autoBC075FDB_ai >= 0 && lv_i <= autoBC075FDB_ae) || (autoBC075FDB_ai <= 0 && lv_i >= autoBC075FDB_ae) ) ; lv_i += autoBC075FDB_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) - lv_dy[lv_i]), (PointGetY(lp_punkt2) - lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
    lv_cleanupgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupLoopBegin(lv_cleanupgroup);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitKill(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
}

void gf_CopyRotateTopRight (int lp_player, point lp_punkt1, point lp_punkt2) {
    int auto63C06FFD_ae;
    int auto63C06FFD_ai;
    int autoE29EE576_ae;
    int autoE29EE576_ai;
    int auto812967DA_ae;
    int auto812967DA_ai;
    int auto6CD5B644_ae;
    int auto6CD5B644_ai;
    int autoFD1AB7BC_ae;
    int autoFD1AB7BC_ai;

    // Variable Declarations
    unitgroup lv_cleanupgroup;
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_cleanupgroup = UnitGroupEmpty();
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto63C06FFD_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto63C06FFD_ai = 1;
    lv_i = 1;
    for ( ; ( (auto63C06FFD_ai >= 0 && lv_i <= auto63C06FFD_ae) || (auto63C06FFD_ai <= 0 && lv_i >= auto63C06FFD_ae) ) ; lv_i += auto63C06FFD_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    autoE29EE576_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoE29EE576_ai = 1;
    lv_i = 1;
    for ( ; ( (autoE29EE576_ai >= 0 && lv_i <= autoE29EE576_ae) || (autoE29EE576_ai <= 0 && lv_i >= autoE29EE576_ae) ) ; lv_i += autoE29EE576_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(PointFromId(32)) - lv_dy[lv_i]), (PointGetY(PointFromId(32)) - lv_dx[lv_i])), 270.0);
    }
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    lv_i = 0;
    auto812967DA_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto812967DA_ai = 1;
    lv_i = 1;
    for ( ; ( (auto812967DA_ai >= 0 && lv_i <= auto812967DA_ae) || (auto812967DA_ai <= 0 && lv_i >= auto812967DA_ae) ) ; lv_i += auto812967DA_ai ) {
        lv_unitname[lv_i] = null;
        lv_dy[lv_i] = 0.0;
        lv_dx[lv_i] = 0.0;
    }
    auto6CD5B644_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto6CD5B644_ai = 1;
    lv_i = 1;
    for ( ; ( (auto6CD5B644_ai >= 0 && lv_i <= auto6CD5B644_ae) || (auto6CD5B644_ai <= 0 && lv_i >= auto6CD5B644_ae) ) ; lv_i += auto6CD5B644_ai ) {
        lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
        lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
        lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
    }
    autoFD1AB7BC_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoFD1AB7BC_ai = 1;
    lv_i = 1;
    for ( ; ( (autoFD1AB7BC_ai >= 0 && lv_i <= autoFD1AB7BC_ae) || (autoFD1AB7BC_ai <= 0 && lv_i >= autoFD1AB7BC_ae) ) ; lv_i += autoFD1AB7BC_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) + lv_dy[lv_i]), (PointGetY(lp_punkt2) - lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
    lv_cleanupgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupLoopBegin(lv_cleanupgroup);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitKill(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
}

void gf_CopyRotateBotLeft (int lp_player, point lp_punkt1, point lp_punkt2) {
    int auto256D4428_ae;
    int auto256D4428_ai;
    int auto7368415E_ae;
    int auto7368415E_ai;
    int auto1D142CBE_ae;
    int auto1D142CBE_ai;
    int auto4BA307BC_ae;
    int auto4BA307BC_ai;
    int auto516F2568_ae;
    int auto516F2568_ai;

    // Variable Declarations
    unitgroup lv_cleanupgroup;
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_cleanupgroup = UnitGroupEmpty();
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto256D4428_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto256D4428_ai = 1;
    lv_i = 1;
    for ( ; ( (auto256D4428_ai >= 0 && lv_i <= auto256D4428_ae) || (auto256D4428_ai <= 0 && lv_i >= auto256D4428_ae) ) ; lv_i += auto256D4428_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    auto7368415E_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto7368415E_ai = 1;
    lv_i = 1;
    for ( ; ( (auto7368415E_ai >= 0 && lv_i <= auto7368415E_ae) || (auto7368415E_ai <= 0 && lv_i >= auto7368415E_ae) ) ; lv_i += auto7368415E_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(PointFromId(32)) - lv_dy[lv_i]), (PointGetY(PointFromId(32)) - lv_dx[lv_i])), 270.0);
    }
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    lv_i = 0;
    auto1D142CBE_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto1D142CBE_ai = 1;
    lv_i = 1;
    for ( ; ( (auto1D142CBE_ai >= 0 && lv_i <= auto1D142CBE_ae) || (auto1D142CBE_ai <= 0 && lv_i >= auto1D142CBE_ae) ) ; lv_i += auto1D142CBE_ai ) {
        lv_unitname[lv_i] = null;
        lv_dy[lv_i] = 0.0;
        lv_dx[lv_i] = 0.0;
    }
    auto4BA307BC_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto4BA307BC_ai = 1;
    lv_i = 1;
    for ( ; ( (auto4BA307BC_ai >= 0 && lv_i <= auto4BA307BC_ae) || (auto4BA307BC_ai <= 0 && lv_i >= auto4BA307BC_ae) ) ; lv_i += auto4BA307BC_ai ) {
        lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
        lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
        lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
    }
    auto516F2568_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto516F2568_ai = 1;
    lv_i = 1;
    for ( ; ( (auto516F2568_ai >= 0 && lv_i <= auto516F2568_ae) || (auto516F2568_ai <= 0 && lv_i >= auto516F2568_ae) ) ; lv_i += auto516F2568_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) - lv_dy[lv_i]), (PointGetY(lp_punkt2) + lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
    lv_cleanupgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupLoopBegin(lv_cleanupgroup);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitKill(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
}

bool gf_BonusRoundDead (int lp_player) {
    // Variable Declarations
    int lv_unitsInMiddle;

    // Variable Initialization

    // Implementation
    lv_unitsInMiddle = UnitCount(null, lp_player, RegionFromId(8), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    if ((lv_unitsInMiddle == 0)) {
        return false;
    }
    else {
        return true;
    }
}

int gf_getlivingplayers () {
    int autoEB1ED12E_ae;
    int autoEB1ED12E_ai;

    // Variable Declarations
    int lv_playersalive;
    int lv_n;

    // Variable Initialization
    lv_playersalive = 8;

    // Implementation
    lv_playersalive = 8;
    lv_n = 0;
    autoEB1ED12E_ae = 8;
    autoEB1ED12E_ai = 1;
    lv_n = 1;
    for ( ; ( (autoEB1ED12E_ai >= 0 && lv_n <= autoEB1ED12E_ae) || (autoEB1ED12E_ai <= 0 && lv_n >= autoEB1ED12E_ae) ) ; lv_n += autoEB1ED12E_ai ) {
        if ((gf_BonusRoundDead(lv_n) == false)) {
            lv_playersalive -= 1;
        }
        else {
        }
    }
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaDirective, IntToText(lv_playersalive));
    return lv_playersalive;
}

void gf_startTimer (int lp_time, int lp_round) {
    // Implementation
    TimerStart(gv_timer, lp_time, false, c_timeGame);
    TimerWindowCreate(gv_timer, (StringExternal("Param/Value/77BA7AAC") + (IntToText(lp_round) + StringExternal("Param/Value/CD3E7278"))), true, false);
    gv_timerWindow = TimerWindowLastCreated();
    Wait(lp_time, c_timeReal);
    TimerWindowDestroy(gv_timerWindow);
    if ((lp_round == 1)) {
        TriggerExecute(gt_Round1, true, false);
    }
    else if ((lp_round == 2)) {
        TriggerExecute(gt_Round2, true, false);
    }
    else if ((lp_round == 3)) {
        TriggerExecute(gt_Round3, true, false);
    }
    else if ((lp_round == 4)) {
        TriggerExecute(gt_Round4, true, false);
    }
    else if ((lp_round == 5)) {
        TriggerExecute(gt_BonusRound1akaRound5, true, false);
    }
    else if ((lp_round == 6)) {
        TriggerExecute(gt_Round6, true, false);
    }
    else if ((lp_round == 7)) {
        TriggerExecute(gt_Round7, true, false);
    }
    else if ((lp_round == 8)) {
        TriggerExecute(gt_Round8, true, false);
    }
    else if ((lp_round == 9)) {
        TriggerExecute(gt_BonusRound2akaRound9, true, false);
    }
    else if ((lp_round == 10)) {
        TriggerExecute(gt_QuarterFinal, true, false);
    }
    TriggerExecute(gt_AntiMoveafterWavestart, true, false);
}

void gf_CopyMidLeft (int lp_player, point lp_punkt1, point lp_punkt2) {
    int auto2FC1045B_ae;
    int auto2FC1045B_ai;
    int auto35279D6C_ae;
    int auto35279D6C_ai;
    int autoC801B290_ae;
    int autoC801B290_ai;
    int autoF56828AF_ae;
    int autoF56828AF_ai;
    int auto94E0E0D0_ae;
    int auto94E0E0D0_ai;

    // Variable Declarations
    unitgroup lv_cleanupgroup;
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_cleanupgroup = UnitGroupEmpty();
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto2FC1045B_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto2FC1045B_ai = 1;
    lv_i = 1;
    for ( ; ( (auto2FC1045B_ai >= 0 && lv_i <= auto2FC1045B_ae) || (auto2FC1045B_ai <= 0 && lv_i >= auto2FC1045B_ae) ) ; lv_i += auto2FC1045B_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    auto35279D6C_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto35279D6C_ai = 1;
    lv_i = 1;
    for ( ; ( (auto35279D6C_ai >= 0 && lv_i <= auto35279D6C_ae) || (auto35279D6C_ai <= 0 && lv_i >= auto35279D6C_ae) ) ; lv_i += auto35279D6C_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(PointFromId(32)) - lv_dy[lv_i]), (PointGetY(PointFromId(32)) - lv_dx[lv_i])), 270.0);
    }
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    lv_i = 0;
    autoC801B290_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoC801B290_ai = 1;
    lv_i = 1;
    for ( ; ( (autoC801B290_ai >= 0 && lv_i <= autoC801B290_ae) || (autoC801B290_ai <= 0 && lv_i >= autoC801B290_ae) ) ; lv_i += autoC801B290_ai ) {
        lv_unitname[lv_i] = null;
        lv_dy[lv_i] = 0.0;
        lv_dx[lv_i] = 0.0;
    }
    autoF56828AF_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoF56828AF_ai = 1;
    lv_i = 1;
    for ( ; ( (autoF56828AF_ai >= 0 && lv_i <= autoF56828AF_ae) || (autoF56828AF_ai <= 0 && lv_i >= autoF56828AF_ae) ) ; lv_i += autoF56828AF_ai ) {
        lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
        lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
        lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
    }
    auto94E0E0D0_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto94E0E0D0_ai = 1;
    lv_i = 1;
    for ( ; ( (auto94E0E0D0_ai >= 0 && lv_i <= auto94E0E0D0_ae) || (auto94E0E0D0_ai <= 0 && lv_i >= auto94E0E0D0_ae) ) ; lv_i += auto94E0E0D0_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) - lv_dy[lv_i]), (PointGetY(lp_punkt2) - lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
    lv_cleanupgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupLoopBegin(lv_cleanupgroup);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitKill(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
}

void gf_CopyMidRight (int lp_player, point lp_punkt1, point lp_punkt2) {
    int autoCB23017B_ae;
    int autoCB23017B_ai;
    int auto87905C22_ae;
    int auto87905C22_ai;
    int autoAE570210_ae;
    int autoAE570210_ai;
    int auto98D766F6_ae;
    int auto98D766F6_ai;
    int auto57D7CD56_ae;
    int auto57D7CD56_ai;

    // Variable Declarations
    unitgroup lv_cleanupgroup;
    int lv_i;
    unitgroup lv_unitgroup;
    fixed[201] lv_dy;
    fixed[201] lv_dx;
    unit[201] lv_unitname;

    // Variable Initialization
    lv_cleanupgroup = UnitGroupEmpty();
    lv_unitgroup = UnitGroupEmpty();

    // Implementation
    RegionSetCenter(RegionFromId(1), Point((PointGetX(lp_punkt1) - 6.0), (PointGetY(lp_punkt1) + 5.0)));
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(1), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    autoCB23017B_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoCB23017B_ai = 1;
    lv_i = 1;
    for ( ; ( (autoCB23017B_ai >= 0 && lv_i <= autoCB23017B_ae) || (autoCB23017B_ai <= 0 && lv_i >= autoCB23017B_ae) ) ; lv_i += autoCB23017B_ai ) {
        if ((UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)) == "Pylon")) {
        }
        else {
            lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
            lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(lp_punkt1));
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
            lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
        }
    }
    auto87905C22_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto87905C22_ai = 1;
    lv_i = 1;
    for ( ; ( (auto87905C22_ai >= 0 && lv_i <= auto87905C22_ae) || (auto87905C22_ai <= 0 && lv_i >= auto87905C22_ae) ) ; lv_i += auto87905C22_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(PointFromId(32)) - lv_dy[lv_i]), (PointGetY(PointFromId(32)) - lv_dx[lv_i])), 270.0);
    }
    lv_unitgroup = null;
    lv_unitgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    lv_i = 0;
    autoAE570210_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    autoAE570210_ai = 1;
    lv_i = 1;
    for ( ; ( (autoAE570210_ai >= 0 && lv_i <= autoAE570210_ae) || (autoAE570210_ai <= 0 && lv_i >= autoAE570210_ae) ) ; lv_i += autoAE570210_ai ) {
        lv_unitname[lv_i] = null;
        lv_dy[lv_i] = 0.0;
        lv_dx[lv_i] = 0.0;
    }
    auto98D766F6_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto98D766F6_ai = 1;
    lv_i = 1;
    for ( ; ( (auto98D766F6_ai >= 0 && lv_i <= auto98D766F6_ae) || (auto98D766F6_ai <= 0 && lv_i >= auto98D766F6_ae) ) ; lv_i += auto98D766F6_ai ) {
        lv_dy[lv_i] = (PointGetY(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetY(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dy[lv_i], c_fixedPrecisionAny));
        lv_dx[lv_i] = (PointGetX(UnitGetPosition(UnitGroupUnit(lv_unitgroup, lv_i))) - PointGetX(PointFromId(32)));
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, FixedToText(lv_dx[lv_i], c_fixedPrecisionAny));
        lv_unitname[lv_i] = UnitGroupUnit(lv_unitgroup, lv_i);
    }
    auto57D7CD56_ae = UnitGroupCount(lv_unitgroup, c_unitCountAlive);
    auto57D7CD56_ai = 1;
    lv_i = 1;
    for ( ; ( (auto57D7CD56_ai >= 0 && lv_i <= auto57D7CD56_ae) || (auto57D7CD56_ai <= 0 && lv_i >= auto57D7CD56_ae) ) ; lv_i += auto57D7CD56_ai ) {
        UnitCreate(1, UnitGetType(UnitGroupUnit(lv_unitgroup, lv_i)), 0, lp_player, Point((PointGetX(lp_punkt2) + lv_dy[lv_i]), (PointGetY(lp_punkt2) - lv_dx[lv_i])), 270.0);
        libNtve_gf_MakeUnitUncommandable(UnitLastCreated(), true);
    }
    lv_cleanupgroup = UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(2), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    UnitGroupLoopBegin(lv_cleanupgroup);
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitKill(UnitGroupLoopCurrent());
    }
    UnitGroupLoopEnd();
}

//--------------------------------------------------------------------------------------------------
// Trigger: T1Dies
//--------------------------------------------------------------------------------------------------
bool gt_T1Dies_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitCreate(RandomInt(1, 2), "MercReaper", 0, 15, PointFromId(1), 270.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_T1Dies_Init () {
    gt_T1Dies = TriggerCreate("gt_T1Dies_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: T2Dies
//--------------------------------------------------------------------------------------------------
bool gt_T2Dies_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitCreate(RandomInt(1, 2), "MercReaper", 0, 15, PointFromId(1), 270.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_T2Dies_Init () {
    gt_T2Dies = TriggerCreate("gt_T2Dies_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: T3Dies
//--------------------------------------------------------------------------------------------------
bool gt_T3Dies_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitCreate(RandomInt(1, 2), "MercReaper", 0, 15, PointFromId(1), 270.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_T3Dies_Init () {
    gt_T3Dies = TriggerCreate("gt_T3Dies_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: T4Dies
//--------------------------------------------------------------------------------------------------
bool gt_T4Dies_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitCreate(RandomInt(1, 2), "MercReaper", 0, 15, PointFromId(1), 270.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_T4Dies_Init () {
    gt_T4Dies = TriggerCreate("gt_T4Dies_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: T5Dies
//--------------------------------------------------------------------------------------------------
bool gt_T5Dies_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitCreate(RandomInt(1, 2), "MercReaper", 0, 15, PointFromId(1), 270.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_T5Dies_Init () {
    gt_T5Dies = TriggerCreate("gt_T5Dies_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Midcleanup
//--------------------------------------------------------------------------------------------------
bool gt_Midcleanup_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(gt_T1Dies, false);
    UnitIssueOrder(UnitFromId(119), Order(AbilityCommand("EnergyNova", 0)), c_orderQueueReplace);
    Wait(5.0, c_timeReal);
    TriggerEnable(gt_T1Dies, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Midcleanup_Init () {
    gt_Midcleanup = TriggerCreate("gt_Midcleanup_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Unit in Bonusround dies
//--------------------------------------------------------------------------------------------------
bool gt_UnitinBonusrounddies_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((libNtve_gf_UnitInRegion(EventUnit(), RegionFromId(8)) == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    if ((UnitGetOwner(EventUnit()) == 15)) {
        if ((libNtve_gf_KillingUnit() == UnitFromId(119))) {
        }
        else {
            PlayerModifyPropertyInt(gv_bonusRoundPlayer, c_playerPropVespene, c_playerPropOperAdd, 10);
            gv_bonusRoundScore[gv_bonusRoundPlayer] += 10;
            TriggerExecute(gt_T1Dies, false, false);
        }
    }
    else {
        TriggerExecute(gt_AntiIdle, true, false);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_UnitinBonusrounddies_Init () {
    gt_UnitinBonusrounddies = TriggerCreate("gt_UnitinBonusrounddies_Func");
    TriggerEnable(gt_UnitinBonusrounddies, false);
    TriggerAddEventUnitDied(gt_UnitinBonusrounddies, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Bonus Round 1 (aka Round 5)
//--------------------------------------------------------------------------------------------------
bool gt_BonusRound1akaRound5_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    gv_nC3A4chsteRunde = 6;
    TriggerExecute(gt_AntiIdle, true, false);
    TriggerEnable(gt_UnitInMiddledies, false);
    TriggerEnable(gt_UnitinBonusrounddies, true);
    gf_CopyMidRight(1, PointFromId(2), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, false);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(1) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, true);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/4A10CA88")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/CEE5B47A"))));
    gv_bonusRoundPlayer += 1;
    gf_CopyMidRight(2, PointFromId(3), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, false);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(2) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, true);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/AD6D9BB0")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/DFF512BA"))));
    gv_bonusRoundPlayer += 1;
    gf_CopyMidRight(3, PointFromId(4), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, true);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(3) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, true);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/E4357519")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/AE256DD4"))));
    gv_bonusRoundPlayer += 1;
    gf_CopyMidRight(4, PointFromId(5), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, true);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(4) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, true);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/D810B9F3")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/71FCB8FD"))));
    gv_bonusRoundPlayer += 1;
    gf_CopyMidRight(5, PointFromId(6), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, true);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(5) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, true);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/3B8E40E2")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/F204C22E"))));
    gv_bonusRoundPlayer += 1;
    gf_CopyMidRight(6, PointFromId(7), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, true);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(6) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, true);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/C3F67ED9")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/FF0FF50C"))));
    gv_bonusRoundPlayer += 1;
    gf_CopyMidRight(7, PointFromId(8), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, true);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(7) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, true);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/5CB2BDF7")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/C72C6D74"))));
    gv_bonusRoundPlayer += 1;
    gf_CopyMidRight(8, PointFromId(9), PointFromId(45));
    TriggerExecute(gt_T1Dies, true, true);
    Wait(2.0, c_timeReal);
    while (!((gf_BonusRoundDead(8) == false))) {
        Wait(5.0, c_timeReal);
    }
    TriggerExecute(gt_Midcleanup, true, false);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, ((PlayerName(gv_bonusRoundPlayer) + StringExternal("Param/Value/B3B15A0A")) + (IntToText(gv_bonusRoundScore[gv_bonusRoundPlayer]) + StringExternal("Param/Value/45163E4C"))));
    gv_bonusRoundPlayer = 1;
    gf_startTimer(30, gv_nC3A4chsteRunde);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_BonusRound1akaRound5_Init () {
    gt_BonusRound1akaRound5 = TriggerCreate("gt_BonusRound1akaRound5_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Bonus Round 2 (aka Round 9)
//--------------------------------------------------------------------------------------------------
bool gt_BonusRound2akaRound9_Func (bool testConds, bool runActions) {
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_BonusRound2akaRound9_Init () {
    gt_BonusRound2akaRound9 = TriggerCreate("gt_BonusRound2akaRound9_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: QuarterFinal
//--------------------------------------------------------------------------------------------------
bool gt_QuarterFinal_Func (bool testConds, bool runActions) {
    int auto68C7D9A2_ae;
    int auto68C7D9A2_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(gt_UnitInMiddledies, true);
    TriggerEnable(gt_UnitinBonusrounddies, false);
    UIClearMessages(PlayerGroupAll(), c_messageAreaAll);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaDirective, StringExternal("Param/Value/C9B8A668"));
    Wait(5.0, c_timeReal);
    UIClearMessages(PlayerGroupAll(), c_messageAreaAll);
    auto68C7D9A2_ae = 8;
    auto68C7D9A2_ai = 1;
    lv_i = 1;
    for ( ; ( (auto68C7D9A2_ai >= 0 && lv_i <= auto68C7D9A2_ae) || (auto68C7D9A2_ai <= 0 && lv_i >= auto68C7D9A2_ae) ) ; lv_i += auto68C7D9A2_ai ) {
        GameOver(lv_i, c_gameOverVictory, true, true);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_QuarterFinal_Init () {
    gt_QuarterFinal = TriggerCreate("gt_QuarterFinal_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: SemiFinal
//--------------------------------------------------------------------------------------------------
bool gt_SemiFinal_Func (bool testConds, bool runActions) {
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_SemiFinal_Init () {
    gt_SemiFinal = TriggerCreate("gt_SemiFinal_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Final
//--------------------------------------------------------------------------------------------------
bool gt_Final_Func (bool testConds, bool runActions) {
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Final_Init () {
    gt_Final = TriggerCreate("gt_Final_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: KillPylo
//--------------------------------------------------------------------------------------------------
bool gt_KillPylo_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "Pylon"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    UnitKill(EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_KillPylo_Init () {
    gt_KillPylo = TriggerCreate("gt_KillPylo_Func");
    TriggerAddEventUnitRegion(gt_KillPylo, null, RegionFromId(7), true);
    TriggerAddEventUnitRegion(gt_KillPylo, null, RegionFromId(18), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Vor1
//--------------------------------------------------------------------------------------------------
bool gt_Vor1_Func (bool testConds, bool runActions) {
    playergroup auto5D567340_g;
    int auto5D567340_p;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    auto5D567340_g = PlayerGroupAll();
    auto5D567340_p = 1;
    for ( ; auto5D567340_p <= PlayerGroupCount(auto5D567340_g) ; auto5D567340_p += BoolToInt(lv_i == PlayerGroupPlayer(auto5D567340_g, auto5D567340_p)) ) {
        lv_i = PlayerGroupPlayer(auto5D567340_g, auto5D567340_p);
        libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "ExtendedThermalLance", 0);
        PlayerModifyPropertyInt(lv_i, c_playerPropSuppliesLimit, c_playerPropOperSetTo, 9999);
        PlayerModifyPropertyInt(lv_i, c_playerPropSuppliesMade, c_playerPropOperSetTo, 9999);
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperSetTo, 150);
    }
    gf_startTimer(60, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Vor1_Init () {
    gt_Vor1 = TriggerCreate("gt_Vor1_Func");
    TriggerAddEventMapInit(gt_Vor1);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Round1
//--------------------------------------------------------------------------------------------------
bool gt_Round1_Func (bool testConds, bool runActions) {
    int autoB2F31A88_ae;
    int autoB2F31A88_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    autoB2F31A88_ae = 8;
    autoB2F31A88_ai = 1;
    lv_i = 1;
    for ( ; ( (autoB2F31A88_ai >= 0 && lv_i <= autoB2F31A88_ae) || (autoB2F31A88_ai <= 0 && lv_i >= autoB2F31A88_ae) ) ; lv_i += autoB2F31A88_ai ) {
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperAdd, 150);
    }
    gf_CopyLeftBot(1, PointFromId(2), PointFromId(19));
    gf_CopyLeftTop(2, PointFromId(3), PointFromId(26));
    gf_CopyRightBot(3, PointFromId(4), PointFromId(23));
    gf_CopyRightTop(4, PointFromId(5), PointFromId(22));
    gf_CopyRotateBotLeft(5, PointFromId(6), PointFromId(20));
    gf_CopyRotateBotRight(6, PointFromId(7), PointFromId(24));
    gf_CopyRotateTopLeft(7, PointFromId(8), PointFromId(25));
    gf_CopyRotateTopRight(8, PointFromId(9), PointFromId(21));
    UnitPauseAll(true);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(6), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(6))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(3), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(3))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(4), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(4))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(5))), c_orderQueueReplace);
    UnitPauseAll(false);
    gv_nC3A4chsteRunde = 2;
    Wait(30.0, c_timeReal);
    TriggerExecute(gt_AntiIdle, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Round1_Init () {
    gt_Round1 = TriggerCreate("gt_Round1_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Round2
//--------------------------------------------------------------------------------------------------
bool gt_Round2_Func (bool testConds, bool runActions) {
    int auto80C0F80B_ae;
    int auto80C0F80B_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    auto80C0F80B_ae = 8;
    auto80C0F80B_ai = 1;
    lv_i = 1;
    for ( ; ( (auto80C0F80B_ai >= 0 && lv_i <= auto80C0F80B_ae) || (auto80C0F80B_ai <= 0 && lv_i >= auto80C0F80B_ae) ) ; lv_i += auto80C0F80B_ai ) {
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperAdd, 300);
    }
    gf_CopyLeftBot(1, PointFromId(2), PointFromId(19));
    gf_CopyLeftTop(3, PointFromId(4), PointFromId(26));
    gf_CopyRightBot(2, PointFromId(3), PointFromId(23));
    gf_CopyRightTop(4, PointFromId(5), PointFromId(22));
    gf_CopyRotateBotLeft(5, PointFromId(6), PointFromId(20));
    gf_CopyRotateBotRight(7, PointFromId(8), PointFromId(24));
    gf_CopyRotateTopLeft(6, PointFromId(7), PointFromId(25));
    gf_CopyRotateTopRight(8, PointFromId(9), PointFromId(21));
    UnitPauseAll(true);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(6), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(6))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(3), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(3))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(4), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(4))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(5))), c_orderQueueReplace);
    UnitPauseAll(false);
    gv_nC3A4chsteRunde = 3;
    Wait(30.0, c_timeReal);
    TriggerExecute(gt_AntiIdle, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Round2_Init () {
    gt_Round2 = TriggerCreate("gt_Round2_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Round3
//--------------------------------------------------------------------------------------------------
bool gt_Round3_Func (bool testConds, bool runActions) {
    int auto85A2A91D_ae;
    int auto85A2A91D_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    auto85A2A91D_ae = 8;
    auto85A2A91D_ai = 1;
    lv_i = 1;
    for ( ; ( (auto85A2A91D_ai >= 0 && lv_i <= auto85A2A91D_ae) || (auto85A2A91D_ai <= 0 && lv_i >= auto85A2A91D_ae) ) ; lv_i += auto85A2A91D_ai ) {
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperAdd, 400);
    }
    gf_CopyLeftBot(1, PointFromId(2), PointFromId(19));
    gf_CopyLeftTop(4, PointFromId(5), PointFromId(26));
    gf_CopyRightBot(2, PointFromId(3), PointFromId(23));
    gf_CopyRightTop(3, PointFromId(4), PointFromId(22));
    gf_CopyRotateBotLeft(5, PointFromId(6), PointFromId(20));
    gf_CopyRotateBotRight(8, PointFromId(9), PointFromId(24));
    gf_CopyRotateTopLeft(6, PointFromId(7), PointFromId(25));
    gf_CopyRotateTopRight(7, PointFromId(8), PointFromId(21));
    UnitPauseAll(true);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(6), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(6))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(3), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(3))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(4), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(4))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(5))), c_orderQueueReplace);
    UnitPauseAll(false);
    gv_nC3A4chsteRunde = 4;
    Wait(30.0, c_timeReal);
    TriggerExecute(gt_AntiIdle, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Round3_Init () {
    gt_Round3 = TriggerCreate("gt_Round3_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Round4
//--------------------------------------------------------------------------------------------------
bool gt_Round4_Func (bool testConds, bool runActions) {
    int auto861D76DE_ae;
    int auto861D76DE_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    auto861D76DE_ae = 8;
    auto861D76DE_ai = 1;
    lv_i = 1;
    for ( ; ( (auto861D76DE_ai >= 0 && lv_i <= auto861D76DE_ae) || (auto861D76DE_ai <= 0 && lv_i >= auto861D76DE_ae) ) ; lv_i += auto861D76DE_ai ) {
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperAdd, 630);
    }
    gf_CopyLeftBot(1, PointFromId(2), PointFromId(19));
    gf_CopyLeftTop(5, PointFromId(6), PointFromId(26));
    gf_CopyRightBot(2, PointFromId(3), PointFromId(23));
    gf_CopyRightTop(6, PointFromId(7), PointFromId(22));
    gf_CopyRotateBotLeft(3, PointFromId(4), PointFromId(20));
    gf_CopyRotateBotRight(7, PointFromId(8), PointFromId(24));
    gf_CopyRotateTopLeft(4, PointFromId(5), PointFromId(25));
    gf_CopyRotateTopRight(8, PointFromId(9), PointFromId(21));
    UnitPauseAll(true);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(6), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(6))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(3), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(3))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(4), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(4))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(5))), c_orderQueueReplace);
    UnitPauseAll(false);
    gv_nC3A4chsteRunde = 5;
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/F0BB2D0B"));
    Wait(30.0, c_timeReal);
    TriggerExecute(gt_AntiIdle, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Round4_Init () {
    gt_Round4 = TriggerCreate("gt_Round4_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Round6
//--------------------------------------------------------------------------------------------------
bool gt_Round6_Func (bool testConds, bool runActions) {
    int autoE3DF8867_ae;
    int autoE3DF8867_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(gt_UnitInMiddledies, true);
    TriggerEnable(gt_UnitinBonusrounddies, false);
    autoE3DF8867_ae = 8;
    autoE3DF8867_ai = 1;
    lv_i = 1;
    for ( ; ( (autoE3DF8867_ai >= 0 && lv_i <= autoE3DF8867_ae) || (autoE3DF8867_ai <= 0 && lv_i >= autoE3DF8867_ae) ) ; lv_i += autoE3DF8867_ai ) {
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperAdd, 600);
    }
    gf_CopyLeftBot(1, PointFromId(2), PointFromId(19));
    gf_CopyLeftTop(6, PointFromId(7), PointFromId(26));
    gf_CopyRightBot(2, PointFromId(3), PointFromId(23));
    gf_CopyRightTop(7, PointFromId(8), PointFromId(22));
    gf_CopyRotateBotLeft(3, PointFromId(4), PointFromId(20));
    gf_CopyRotateBotRight(8, PointFromId(9), PointFromId(24));
    gf_CopyRotateTopLeft(4, PointFromId(5), PointFromId(25));
    gf_CopyRotateTopRight(5, PointFromId(6), PointFromId(21));
    UnitPauseAll(true);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(6), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(6))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(3), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(3))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(4), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(4))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(5))), c_orderQueueReplace);
    UnitPauseAll(false);
    gv_nC3A4chsteRunde = 7;
    Wait(30.0, c_timeReal);
    TriggerExecute(gt_AntiIdle, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Round6_Init () {
    gt_Round6 = TriggerCreate("gt_Round6_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Round7
//--------------------------------------------------------------------------------------------------
bool gt_Round7_Func (bool testConds, bool runActions) {
    int autoAA3AFB8F_ae;
    int autoAA3AFB8F_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    autoAA3AFB8F_ae = 8;
    autoAA3AFB8F_ai = 1;
    lv_i = 1;
    for ( ; ( (autoAA3AFB8F_ai >= 0 && lv_i <= autoAA3AFB8F_ae) || (autoAA3AFB8F_ai <= 0 && lv_i >= autoAA3AFB8F_ae) ) ; lv_i += autoAA3AFB8F_ai ) {
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperAdd, 1000);
        libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "ExtendedThermalLance", 0);
    }
    gf_CopyLeftBot(1, PointFromId(2), PointFromId(19));
    gf_CopyLeftTop(7, PointFromId(8), PointFromId(26));
    gf_CopyRightBot(2, PointFromId(3), PointFromId(23));
    gf_CopyRightTop(8, PointFromId(9), PointFromId(22));
    gf_CopyRotateBotLeft(3, PointFromId(4), PointFromId(20));
    gf_CopyRotateBotRight(5, PointFromId(6), PointFromId(24));
    gf_CopyRotateTopLeft(4, PointFromId(5), PointFromId(25));
    gf_CopyRotateTopRight(6, PointFromId(7), PointFromId(21));
    UnitPauseAll(true);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(6), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(6))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(3), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(3))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(4), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(4))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(5))), c_orderQueueReplace);
    UnitPauseAll(false);
    gv_nC3A4chsteRunde = 8;
    Wait(30.0, c_timeReal);
    TriggerExecute(gt_AntiIdle, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Round7_Init () {
    gt_Round7 = TriggerCreate("gt_Round7_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Round8
//--------------------------------------------------------------------------------------------------
bool gt_Round8_Func (bool testConds, bool runActions) {
    int autoE02A2EE8_ae;
    int autoE02A2EE8_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    autoE02A2EE8_ae = 8;
    autoE02A2EE8_ai = 1;
    lv_i = 1;
    for ( ; ( (autoE02A2EE8_ai >= 0 && lv_i <= autoE02A2EE8_ae) || (autoE02A2EE8_ai <= 0 && lv_i >= autoE02A2EE8_ae) ) ; lv_i += autoE02A2EE8_ai ) {
        PlayerModifyPropertyInt(lv_i, c_playerPropMinerals, c_playerPropOperAdd, 1000);
    }
    gf_CopyLeftBot(1, PointFromId(2), PointFromId(19));
    gf_CopyLeftTop(8, PointFromId(9), PointFromId(26));
    gf_CopyRightBot(2, PointFromId(3), PointFromId(23));
    gf_CopyRightTop(5, PointFromId(6), PointFromId(22));
    gf_CopyRotateBotLeft(3, PointFromId(4), PointFromId(20));
    gf_CopyRotateBotRight(6, PointFromId(7), PointFromId(24));
    gf_CopyRotateTopLeft(4, PointFromId(5), PointFromId(25));
    gf_CopyRotateTopRight(7, PointFromId(8), PointFromId(21));
    UnitPauseAll(true);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(6), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(6))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(3), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(3))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(4), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(4))), c_orderQueueReplace);
    UnitGroupIssueOrder(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), OrderTargetingPoint(AbilityCommand("attack", 0), RegionGetCenter(RegionFromId(5))), c_orderQueueReplace);
    UnitPauseAll(false);
    gv_nC3A4chsteRunde = 9;
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringExternal("Param/Value/AB060DB1"));
    Wait(30.0, c_timeReal);
    TriggerExecute(gt_AntiIdle, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Round8_Init () {
    gt_Round8 = TriggerCreate("gt_Round8_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Killall
//--------------------------------------------------------------------------------------------------
bool gt_Killall_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitIssueOrder(UnitFromId(119), Order(AbilityCommand("EnergyNova", 0)), c_orderQueueReplace);
    TriggerExecute(gt_DestroyDialog, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Killall_Init () {
    gt_Killall = TriggerCreate("gt_Killall_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Anti-Idle
//--------------------------------------------------------------------------------------------------
bool gt_AntiIdle_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(11), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(1)), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(9), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(1)), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(10), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(1)), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(12), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(1)), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(8), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        UnitIssueOrder(UnitGroupLoopCurrent(), OrderTargetingPoint(AbilityCommand("attack", 0), PointFromId(1)), c_orderQueueAddToEnd);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AntiIdle_Init () {
    gt_AntiIdle = TriggerCreate("gt_AntiIdle_Func");
    TriggerAddEventTimePeriodic(gt_AntiIdle, 20.0, c_timeReal);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Unit In Middle dies
//--------------------------------------------------------------------------------------------------
bool gt_UnitInMiddledies_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_n;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!(((libNtve_gf_UnitInRegion(EventUnit(), RegionFromId(7)) == true) && (UnitGetOwner(libNtve_gf_KillingUnit()) != 15)))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(gt_DestroyDialog, true, false);
    lv_n = 0;
    if ((gf_getlivingplayers() == 1)) {
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, (StringExternal("Param/Value/1A1EA7AB") + IntToText(libNtve_gf_KillingPlayer())));
        TriggerExecute(gt_Killall, true, true);
        Wait(0.5, c_timeReal);
        gv_kills[libNtve_gf_KillingPlayer()] += libNtve_gf_UnitGetPropertyKills(UnitFromId(119), c_unitPropCurrent);
        UnitSetPropertyFixed(UnitFromId(119), c_unitPropKills, 0.0);
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, (StringExternal("Param/Value/75D60C18") + IntToText(gv_kills[libNtve_gf_KillingPlayer()])));
        TriggerExecute(gt_DestroyDialog, true, false);
        gf_startTimer(30, gv_nC3A4chsteRunde);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_UnitInMiddledies_Init () {
    gt_UnitInMiddledies = TriggerCreate("gt_UnitInMiddledies_Func");
    TriggerAddEventUnitDied(gt_UnitInMiddledies, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: CreateBank
//--------------------------------------------------------------------------------------------------
bool gt_CreateBank_Func (bool testConds, bool runActions) {
    int autoD1852FA5_ae;
    int autoD1852FA5_ai;

    // Variable Declarations
    string lv_hashcode;
    int lv_i;
    int lv_true;

    // Variable Initialization
    lv_hashcode = "";

    // Actions
    if (!runActions) {
        return true;
    }

    autoD1852FA5_ae = 8;
    autoD1852FA5_ai = 1;
    lv_i = 1;
    for ( ; ( (autoD1852FA5_ai >= 0 && lv_i <= autoD1852FA5_ae) || (autoD1852FA5_ai <= 0 && lv_i >= autoD1852FA5_ae) ) ; lv_i += autoD1852FA5_ai ) {
        if ((PlayerType(lv_i) == c_playerTypeUser)) {
            BankLoad("BloodTournament", lv_i);
            BankOptionSet(BankLastCreated(), c_bankOptionSignature, true);
            BankSectionCreate(BankLastCreated(), "Stats");
            BankSectionCreate(BankLastCreated(), "Achivement");
            BankSectionCreate(BankLastCreated(), "Security");
            BankSectionCreate(BankLastCreated(), "Random_Stuff");
            BankValueSetFromString(BankLastCreated(), "Random_Stuff", "ID", PlayerHandle(lv_i));
            gv_bank[lv_i] = BankLastCreated();
            gv_bank_wins[lv_i] = BankValueGetAsInt(gv_bank[lv_i], "Stats", "Wins");
            gv_bank_loses[lv_i] = BankValueGetAsInt(gv_bank[lv_i], "Stats", "Loses");
            gv_bank_kills[lv_i] = BankValueGetAsInt(gv_bank[lv_i], "Stats", "Kills");
            gv_bank_wins_sec[lv_i] = BankValueGetAsString(gv_bank[lv_i], "Security", "Wins");
            gv_bank_loses_sec[lv_i] = BankValueGetAsString(gv_bank[lv_i], "Security", "Loses");
            gv_bank_kills_sec[lv_i] = BankValueGetAsString(gv_bank[lv_i], "Security", "Kills");
            BankValueSetFromInt(BankLastCreated(), "Debug", "Kills", gv_bank_kills[lv_i]);
            BankValueSetFromInt(BankLastCreated(), "Debug", "Loses", gv_bank_loses[lv_i]);
            BankValueSetFromInt(BankLastCreated(), "Debug", "Wins", gv_bank_wins[lv_i]);
            lib1_gf_InitializeHashInput();
            lib1_gf_AddStringToHashInput(gv_bank_code);
            lib1_gf_AddIntegerToHashInput(gv_bank_wins[lv_i]);
            lv_hashcode = lib1_gf_GenerateSHA256HashCode();
            if ((lv_hashcode == gv_bank_wins_sec[lv_i])) {
            }
            else {
                lv_true += 1;
            }
            lib1_gf_InitializeHashInput();
            lib1_gf_AddStringToHashInput(gv_bank_code);
            lib1_gf_AddIntegerToHashInput(gv_bank_loses[lv_i]);
            lv_hashcode = lib1_gf_GenerateSHA256HashCode();
            if ((lv_hashcode == gv_bank_loses_sec[lv_i])) {
            }
            else {
                lv_true += 1;
            }
            lib1_gf_InitializeHashInput();
            lib1_gf_AddStringToHashInput(gv_bank_code);
            lib1_gf_AddIntegerToHashInput(gv_bank_kills[lv_i]);
            lv_hashcode = lib1_gf_GenerateSHA256HashCode();
            if ((lv_hashcode == gv_bank_kills_sec[lv_i])) {
            }
            else {
                lv_true += 1;
            }
            if ((lv_true != 0)) {
                BankSectionRemove(gv_bank[lv_i], "Stats");
                BankSectionRemove(gv_bank[lv_i], "Security");
                BankSectionRemove(gv_bank[lv_i], "Random_Stuff");
                BankSectionRemove(gv_bank[lv_i], "Achivement");
                BankSectionCreate(gv_bank[lv_i], "Stats");
                BankSectionCreate(gv_bank[lv_i], "Achivement");
                BankSectionCreate(gv_bank[lv_i], "Security");
                BankSectionCreate(gv_bank[lv_i], "Random_Stuff");
            }
            else {
            }
            lv_true = 0;
        }
        else {
            UIDisplayMessage(PlayerGroupSingle(lv_i), c_messageAreaChat, StringExternal("Param/Value/328D0FE3"));
        }
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_CreateBank_Init () {
    gt_CreateBank = TriggerCreate("gt_CreateBank_Func");
    TriggerAddEventMapInit(gt_CreateBank);
}

//--------------------------------------------------------------------------------------------------
// Trigger: SaveBanks
//--------------------------------------------------------------------------------------------------
bool gt_SaveBanks_Func (bool testConds, bool runActions) {
    int autoC6D60BBB_ae;
    int autoC6D60BBB_ai;

    // Variable Declarations
    string lv_hash;
    int lv_i;
    int lv_w;
    int lv_l;

    // Variable Initialization
    lv_hash = "";

    // Actions
    if (!runActions) {
        return true;
    }

    autoC6D60BBB_ae = 8;
    autoC6D60BBB_ai = 1;
    lv_i = 1;
    for ( ; ( (autoC6D60BBB_ai >= 0 && lv_i <= autoC6D60BBB_ae) || (autoC6D60BBB_ai <= 0 && lv_i >= autoC6D60BBB_ae) ) ; lv_i += autoC6D60BBB_ai ) {
        if ((PlayerType(lv_i) == c_playerTypeUser)) {
            BankValueSetFromInt(gv_bank[lv_i], "Stats", "Wins", (gv_bank_wins[lv_i] + lv_w));
            BankValueSetFromInt(gv_bank[lv_i], "Stats", "Loses", (gv_bank_loses[lv_i] + lv_l));
            BankValueSetFromInt(gv_bank[lv_i], "Stats", "Kills", (gv_bank_kills[lv_i] + gv_kills[lv_i]));
            lib1_gf_InitializeHashInput();
            lib1_gf_AddStringToHashInput(gv_bank_code);
            lib1_gf_AddIntegerToHashInput((gv_bank_wins[lv_i] + lv_w));
            lv_hash = lib1_gf_GenerateSHA256HashCode();
            BankValueSetFromString(gv_bank[lv_i], "Security", "Wins", lv_hash);
            lib1_gf_InitializeHashInput();
            lib1_gf_AddStringToHashInput(gv_bank_code);
            lib1_gf_AddIntegerToHashInput((gv_bank_loses[lv_i] + lv_l));
            lv_hash = lib1_gf_GenerateSHA256HashCode();
            BankValueSetFromString(gv_bank[lv_i], "Security", "Loses", lv_hash);
            lib1_gf_InitializeHashInput();
            lib1_gf_AddStringToHashInput(gv_bank_code);
            lib1_gf_AddIntegerToHashInput((gv_bank_kills[lv_i] + gv_kills[lv_i]));
            lv_hash = lib1_gf_GenerateSHA256HashCode();
            BankValueSetFromString(gv_bank[lv_i], "Security", "Kills", lv_hash);
            lib1_gf_InitializeHashInput();
            lib1_gf_AddStringToHashInput(gv_bank_code);
            lib1_gf_AddStringToHashInput(PlayerHandle(lv_i));
            lv_hash = lib1_gf_GenerateSHA256HashCode();
            BankValueSetFromString(gv_bank[lv_i], "Security", "ID", lv_hash);
            BankSave(gv_bank[lv_i]);
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, StringExternal("Param/Value/406D7FDF"));
        }
        else {
        }
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_SaveBanks_Init () {
    gt_SaveBanks = TriggerCreate("gt_SaveBanks_Func");
    TriggerAddEventChatMessage(gt_SaveBanks, c_playerAny, "-save", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -getAlivePlayers
//--------------------------------------------------------------------------------------------------
bool gt_getAlivePlayers_Func (bool testConds, bool runActions) {
    int auto005D0F5E_ae;
    int auto005D0F5E_ai;

    // Variable Declarations
    int lv_playersalive;
    int lv_n;

    // Variable Initialization
    lv_playersalive = 8;

    // Actions
    if (!runActions) {
        return true;
    }

    lv_playersalive = 8;
    lv_n = 0;
    auto005D0F5E_ae = 8;
    auto005D0F5E_ai = 1;
    lv_n = 1;
    for ( ; ( (auto005D0F5E_ai >= 0 && lv_n <= auto005D0F5E_ae) || (auto005D0F5E_ai <= 0 && lv_n >= auto005D0F5E_ae) ) ; lv_n += auto005D0F5E_ai ) {
        if ((gf_BonusRoundDead(lv_n) == false)) {
            lv_playersalive -= 1;
        }
        else {
        }
    }
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaDirective, IntToText(lv_playersalive));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_getAlivePlayers_Init () {
    gt_getAlivePlayers = TriggerCreate("gt_getAlivePlayers_Func");
    TriggerAddEventChatMessage(gt_getAlivePlayers, c_playerAny, "-getaliveplayers", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -testtextpos
//--------------------------------------------------------------------------------------------------
bool gt_testtextpos_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaDirective, StringExternal("Param/Value/245D6B09"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaChat, StringExternal("Param/Value/93A20E9F"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaCheat, StringExternal("Param/Value/B4CC993B"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaDebug, StringExternal("Param/Value/84C5780A"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaError, StringExternal("Param/Value/6EDD504E"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaSubtitle, StringExternal("Param/Value/FD882DE6"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaCinematic, StringExternal("Param/Value/FD65577B"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaWarning, StringExternal("Param/Value/8AD7F4D2"));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaObjective, StringExternal("Param/Value/4C49BD86"));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_testtextpos_Init () {
    gt_testtextpos = TriggerCreate("gt_testtextpos_Func");
    TriggerAddEventChatMessage(gt_testtextpos, c_playerAny, "-testtextpos", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Unstuck
//--------------------------------------------------------------------------------------------------
bool gt_Unstuck_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, StringExternal("Param/Value/5DC4751A"));
    if ((gv_playerunstucks[EventPlayer()] == false)) {
        gv_playerunstucks[EventPlayer()] = true;
        gv_unstucks += 1;
        if ((gv_unstucks >= RoundI((IntToFixed(PlayerGroupCount(PlayerGroupAlliance(c_playerGroupEnemy, 1))) / 2.0)))) {
            TriggerExecute(gt_AntiIdle, true, false);
            gv_unstucks = 0;
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, StringExternal("Param/Value/B6B8581B"));
            gv_playerunstucks[1] = false;
            gv_playerunstucks[2] = false;
            gv_playerunstucks[3] = false;
            gv_playerunstucks[4] = false;
            gv_playerunstucks[5] = false;
            gv_playerunstucks[6] = false;
            gv_playerunstucks[7] = false;
            gv_playerunstucks[8] = false;
        }
        else {
            UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, (IntToText(gv_unstucks) + StringExternal("Param/Value/046C7A0E")));
        }
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_Unstuck_Init () {
    gt_Unstuck = TriggerCreate("gt_Unstuck_Func");
    TriggerAddEventChatMessage(gt_Unstuck, c_playerAny, "-unstuck", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -beta
//--------------------------------------------------------------------------------------------------
bool gt_beta_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    if (((PlayerHandle(EventPlayer()) == "2-S2-1-1749687") || (PlayerHandle(EventPlayer()) == "2-S2-1-2359579") || (PlayerHandle(EventPlayer()) == "2-S2-1-1557643") || (PlayerHandle(EventPlayer()) == "2-S2-1-1903968") || (GameIsOnline() == false))) {
        gv_betatester[EventPlayer()] = true;
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaChat, StringExternal("Param/Value/E3F45CB3"));
        HelpPanelAddTip(PlayerGroupSingle(EventPlayer()), libNtve_gf_FormatTipTitle(StringExternal("Param/Value/3627DA5E"), 4), StringExternal("Param/Value/C9271509"), StringExternal("Param/Value/AAAF54A7"), "Assets\\Textures\\btn-upgrade-protoss-groundweaponslevel3.dds");
    }
    else {
        SoundPlay(SoundLink("330mmBarrageCannonsUnMorph", 0), PlayerGroupSingle(EventPlayer()), 100.0, 0.0);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_beta_Init () {
    gt_beta = TriggerCreate("gt_beta_Func");
    TriggerAddEventChatMessage(gt_beta, c_playerAny, "-beta", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -code
//--------------------------------------------------------------------------------------------------
bool gt_code_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaChat, StringToText(PlayerHandle(EventPlayer())));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_code_Init () {
    gt_code = TriggerCreate("gt_code_Func");
    TriggerAddEventChatMessage(gt_code, c_playerAny, "-code", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -give
//--------------------------------------------------------------------------------------------------
bool gt_give_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_player;
    int lv_amount;
    bool lv_vespine;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((gv_betatester[EventPlayer()] == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    lv_player = StringToInt(StringWord(EventChatMessage(false), 2));
    lv_amount = StringToInt(StringWord(EventChatMessage(false), 3));
    if ((StringWord(EventChatMessage(false), 4) == "V")) {
        PlayerModifyPropertyInt(lv_player, c_playerPropVespene, c_playerPropOperAdd, lv_amount);
    }
    else {
        PlayerModifyPropertyInt(lv_player, c_playerPropMinerals, c_playerPropOperAdd, lv_amount);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_give_Init () {
    gt_give = TriggerCreate("gt_give_Func");
    TriggerAddEventChatMessage(gt_give, c_playerAny, "-give", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -kick
//--------------------------------------------------------------------------------------------------
bool gt_kick_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((gv_betatester[EventPlayer()] == true))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    GameOver(StringToInt(StringWord(EventChatMessage(false), 2)), c_gameOverDefeat, false, false);
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaWarning, (PlayerName(StringToInt(StringWord(EventChatMessage(false), 2))) + StringExternal("Param/Value/BD680F96")));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_kick_Init () {
    gt_kick = TriggerCreate("gt_kick_Func");
    TriggerAddEventChatMessage(gt_kick, c_playerAny, "-kick", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -resetBank
//--------------------------------------------------------------------------------------------------
bool gt_resetBank_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!(((PlayerHandle(EventPlayer()) == "2-S2-1-1749687") || (PlayerHandle(EventPlayer()) == "2-S2-1-1903968")))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    gv_banktoreset = StringToInt(StringWord(EventChatMessage(false), 2));
    gv_invocer = EventPlayer();
    gv_texttotypein = (PlayerHandle(gv_banktoreset) + IntToString(gv_invocer));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaChat, (StringExternal("Param/Value/4FED955C") + (StringToText(gv_texttotypein) + StringExternal("Param/Value/C5A94878"))));
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaChat, StringExternal("Param/Value/08A59D38"));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_resetBank_Init () {
    gt_resetBank = TriggerCreate("gt_resetBank_Func");
    TriggerAddEventChatMessage(gt_resetBank, c_playerAny, "-resetBank", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: shure
//--------------------------------------------------------------------------------------------------
bool gt_shure_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((PlayerHandle(EventPlayer()) == "2-S2-1-1749687"))) {
            return false;
        }

        if (!((EventChatMessage(false) == gv_texttotypein))) {
            return false;
        }

        if (!((PlayerHandle(EventPlayer()) == "2-S2-1-1903968"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    BankSectionRemove(gv_bank[gv_banktoreset], "Stats");
    BankSectionRemove(gv_bank[gv_banktoreset], "Achivement");
    BankSectionRemove(gv_bank[gv_banktoreset], "Security");
    BankSectionRemove(gv_bank[gv_banktoreset], "Random_Stuff");
    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaChat, StringExternal("Param/Value/651ABCAE"));
    BankSave(gv_bank[gv_banktoreset]);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_shure_Init () {
    gt_shure = TriggerCreate("gt_shure_Func");
    TriggerAddEventChatMessage(gt_shure, c_playerAny, "", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: -id
//--------------------------------------------------------------------------------------------------
bool gt_id_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UIDisplayMessage(PlayerGroupSingle(EventPlayer()), c_messageAreaChat, (StringExternal("Param/Value/FDCD1AA1") + StringToText(PlayerHandle(EventPlayer()))));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_id_Init () {
    gt_id = TriggerCreate("gt_id_Func");
    TriggerAddEventChatMessage(gt_id, c_playerAny, "-id", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: CreateDialog
//--------------------------------------------------------------------------------------------------
bool gt_CreateDialog_Func (bool testConds, bool runActions) {
    int autoDD41E6D1_ae;
    int autoDD41E6D1_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization
    lv_i = 1;

    // Actions
    if (!runActions) {
        return true;
    }

    DialogCreate(500, 400, c_anchorBottomRight, 0, 0, true);
    gv_killDialogfenster = DialogLastCreated();
    DialogSetImage(gv_killDialogfenster, "Assets\\Textures\\blank.dds");
    autoDD41E6D1_ae = 8;
    autoDD41E6D1_ai = 1;
    lv_i = 1;
    for ( ; ( (autoDD41E6D1_ai >= 0 && lv_i <= autoDD41E6D1_ae) || (autoDD41E6D1_ai <= 0 && lv_i >= autoDD41E6D1_ae) ) ; lv_i += autoDD41E6D1_ai ) {
        libNtve_gf_CreateDialogItemLabel(gv_killDialogfenster, 50, 50, c_anchorTopLeft, 50, (50 - (50 * lv_i)), ((PlayerName(lv_i) + StringExternal("Param/Value/A99E6FCA")) + (IntToText(gv_kills[lv_i]) + StringExternal("Param/Value/583DDDD4"))), ColorWithAlpha(0,0,0,0), false, 0.0);
        gv_killDialoggegenstand[lv_i] = DialogControlLastCreated();
    }
    DialogSetVisible(gv_killDialogfenster, PlayerGroupAll(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_CreateDialog_Init () {
    gt_CreateDialog = TriggerCreate("gt_CreateDialog_Func");
    TriggerAddEventMapInit(gt_CreateDialog);
}

//--------------------------------------------------------------------------------------------------
// Trigger: DestroyDialog
//--------------------------------------------------------------------------------------------------
bool gt_DestroyDialog_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    DialogDestroy(gv_killDialogfenster);
    TriggerExecute(gt_CreateDialog, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_DestroyDialog_Init () {
    gt_DestroyDialog = TriggerCreate("gt_DestroyDialog_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Global Ini
//--------------------------------------------------------------------------------------------------
bool gt_GlobalIni_Func (bool testConds, bool runActions) {
    int autoDD765298_ae;
    int autoDD765298_ai;

    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    autoDD765298_ae = 9;
    autoDD765298_ai = 1;
    lv_i = 1;
    for ( ; ( (autoDD765298_ai >= 0 && lv_i <= autoDD765298_ae) || (autoDD765298_ai <= 0 && lv_i >= autoDD765298_ae) ) ; lv_i += autoDD765298_ai ) {
        VisRevealArea(lv_i, RegionEntireMap(), 0.0, false);
        PlayerModifyPropertyInt(1, c_playerPropMinerals, c_playerPropOperSetTo, 1000);
        libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "ExtendedThermalLance", 1);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_GlobalIni_Init () {
    gt_GlobalIni = TriggerCreate("gt_GlobalIni_Func");
    TriggerAddEventMapInit(gt_GlobalIni);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Anti-MoveafterBuild
//--------------------------------------------------------------------------------------------------
bool gt_AntiMoveafterBuild_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitBehaviorAdd(EventUnit(), "Invulnerable", UnitFromId(119), 1);
    Wait(2.0, c_timeReal);
    libNtve_gf_PauseUnit(EventUnit(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AntiMoveafterBuild_Init () {
    gt_AntiMoveafterBuild = TriggerCreate("gt_AntiMoveafterBuild_Func");
    TriggerAddEventUnitRegion(gt_AntiMoveafterBuild, null, RegionFromId(15), true);
    TriggerAddEventUnitRegion(gt_AntiMoveafterBuild, null, RegionFromId(16), true);
    TriggerAddEventUnitRegion(gt_AntiMoveafterBuild, null, RegionFromId(13), true);
    TriggerAddEventUnitRegion(gt_AntiMoveafterBuild, null, RegionFromId(14), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Kill Noob
//--------------------------------------------------------------------------------------------------
bool gt_KillNoob_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) != "Larva"))) {
            return false;
        }

        if (!((UnitGetType(EventUnit()) != "Pylon"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    lv_i += 1;
    if ((UnitGetOwner(EventUnit()) == 1)) {
        UnitKill(UnitFromId(78));
    }
    else if ((UnitGetOwner(EventUnit()) == 2)) {
        UnitKill(UnitFromId(79));
    }
    else if ((UnitGetOwner(EventUnit()) == 3)) {
        UnitKill(UnitFromId(80));
    }
    else if ((UnitGetOwner(EventUnit()) == 4)) {
        UnitKill(UnitFromId(81));
    }
    else if ((UnitGetOwner(EventUnit()) == 5)) {
        UnitKill(UnitFromId(82));
    }
    else if ((UnitGetOwner(EventUnit()) == 6)) {
        UnitKill(UnitFromId(83));
    }
    else if ((UnitGetOwner(EventUnit()) == 7)) {
        UnitKill(UnitFromId(84));
    }
    else if ((UnitGetOwner(EventUnit()) == 8)) {
        UnitKill(UnitFromId(85));
    }
    if ((lv_i == 8)) {
        TriggerEnable(TriggerGetCurrent(), false);
    }
    else {
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_KillNoob_Init () {
    gt_KillNoob = TriggerCreate("gt_KillNoob_Func");
    TriggerAddEventUnitRegion(gt_KillNoob, null, RegionFromId(13), true);
    TriggerAddEventUnitRegion(gt_KillNoob, null, RegionFromId(15), true);
    TriggerAddEventUnitRegion(gt_KillNoob, null, RegionFromId(16), true);
    TriggerAddEventUnitRegion(gt_KillNoob, null, RegionFromId(14), true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Anti-MoveafterWavestart
//--------------------------------------------------------------------------------------------------
bool gt_AntiMoveafterWavestart_Func (bool testConds, bool runActions) {
    // Actions
    if (!runActions) {
        return true;
    }

    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(16), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(15), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(13), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    UnitGroupLoopBegin(UnitGroupAlliance(c_playerAny, c_unitAllianceAny, RegionFromId(14), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    for ( ; !UnitGroupLoopDone() ; UnitGroupLoopStep() ) {
        libNtve_gf_PauseUnit(UnitGroupLoopCurrent(), true);
    }
    UnitGroupLoopEnd();
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_AntiMoveafterWavestart_Init () {
    gt_AntiMoveafterWavestart = TriggerCreate("gt_AntiMoveafterWavestart_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: BanditCrit
//--------------------------------------------------------------------------------------------------
bool gt_BanditCrit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_basedmg;
    fixed lv_critdmg;
    fixed lv_fulldmg;

    // Variable Initialization
    lv_basedmg = UnitWeaponDamage(EventUnitDamageSourceUnit(), 1, c_unitAttributeNone, false);
    lv_critdmg = StringToFixed(CatalogFieldValueGet(c_gameCatalogEffect, "BanditCrit", "Amount", EventUnitDamageSourcePlayer()));
    lv_fulldmg = (lv_basedmg + lv_critdmg);

    // Actions
    if (!runActions) {
        return true;
    }

    TextTagCreate(FixedToText(lv_fulldmg, 0), 30, UnitGetPosition(EventUnitDamageSourceUnit()), 1.0, true, false, PlayerGroupAll());
    TextTagSetColor(TextTagLastCreated(), c_textTagColorText, Color(100.00, 0.00, 0.00));
    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 5.0);
    TextTagSetVelocity(TextTagLastCreated(), 0.5, 90.0);
    TextTagShow(TextTagLastCreated(), PlayerGroupAll(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_BanditCrit_Init () {
    gt_BanditCrit = TriggerCreate("gt_BanditCrit_Func");
    TriggerAddEventUnitDamaged(gt_BanditCrit, null, c_unitDamageTypeAny, c_unitDamageEither, "BanditCrit");
}

//--------------------------------------------------------------------------------------------------
// Trigger: KnightDmgReduce
//--------------------------------------------------------------------------------------------------
bool gt_KnightDmgReduce_Func (bool testConds, bool runActions) {
    // Conditions
    if (testConds) {
        if (!((UnitGetType(EventUnit()) == "KnightGeneral"))) {
            return false;
        }
    }

    // Actions
    if (!runActions) {
        return true;
    }

    UnitSetPropertyFixed(EventUnit(), c_unitPropLife, (UnitGetPropertyFixed(EventUnit(), c_unitPropLife, c_unitPropCurrent) + (EventUnitDamageAmount() * 0.3)));
    return true;
}

//--------------------------------------------------------------------------------------------------
void gt_KnightDmgReduce_Init () {
    gt_KnightDmgReduce = TriggerCreate("gt_KnightDmgReduce_Func");
    TriggerEnable(gt_KnightDmgReduce, false);
    TriggerAddEventUnitDamaged(gt_KnightDmgReduce, null, c_unitDamageTypeAny, c_unitDamageEither, "Engage");
}

//--------------------------------------------------------------------------------------------------
// Trigger Initialization
//--------------------------------------------------------------------------------------------------
void InitTriggers () {
    gt_T1Dies_Init();
    gt_T2Dies_Init();
    gt_T3Dies_Init();
    gt_T4Dies_Init();
    gt_T5Dies_Init();
    gt_Midcleanup_Init();
    gt_UnitinBonusrounddies_Init();
    gt_BonusRound1akaRound5_Init();
    gt_BonusRound2akaRound9_Init();
    gt_QuarterFinal_Init();
    gt_SemiFinal_Init();
    gt_Final_Init();
    gt_KillPylo_Init();
    gt_Vor1_Init();
    gt_Round1_Init();
    gt_Round2_Init();
    gt_Round3_Init();
    gt_Round4_Init();
    gt_Round6_Init();
    gt_Round7_Init();
    gt_Round8_Init();
    gt_Killall_Init();
    gt_AntiIdle_Init();
    gt_UnitInMiddledies_Init();
    gt_CreateBank_Init();
    gt_SaveBanks_Init();
    gt_getAlivePlayers_Init();
    gt_testtextpos_Init();
    gt_Unstuck_Init();
    gt_beta_Init();
    gt_code_Init();
    gt_give_Init();
    gt_kick_Init();
    gt_resetBank_Init();
    gt_shure_Init();
    gt_id_Init();
    gt_CreateDialog_Init();
    gt_DestroyDialog_Init();
    gt_GlobalIni_Init();
    gt_AntiMoveafterBuild_Init();
    gt_KillNoob_Init();
    gt_AntiMoveafterWavestart_Init();
    gt_BanditCrit_Init();
    gt_KnightDmgReduce_Init();
}

//--------------------------------------------------------------------------------------------------
// Map Initialization
//--------------------------------------------------------------------------------------------------
void InitMap () {
    InitLibs();
    InitGlobals();
    InitTriggers();
}