diff options
Diffstat (limited to 'tests/src/JIT')
167 files changed, 67759 insertions, 811 deletions
diff --git a/tests/src/JIT/CodeGenBringUpTests/Rotate.cs b/tests/src/JIT/CodeGenBringUpTests/Rotate.cs index 74a936ef13..9c5d9599a6 100644 --- a/tests/src/JIT/CodeGenBringUpTests/Rotate.cs +++ b/tests/src/JIT/CodeGenBringUpTests/Rotate.cs @@ -102,12 +102,38 @@ public class Test [MethodImpl(MethodImplOptions.NoInlining)] static ulong rol64const() { - ulong value = flag() ? (ulong)0x123456789abcdef : (ulong)0x123456789abcdef; + ulong value = flag() ? (ulong)0x123456789abcdef : (ulong)0xabcdef123456789; int amount = 16; return (value >> (64 - amount)) | (value << amount); } [MethodImpl(MethodImplOptions.NoInlining)] + static ulong rol64_16(ulong value) + { + return (value >> (64 - 16)) | (value << 16); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong rol64_32(ulong value) + { + return (value >> (64 - 32)) | (value << 32); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong rol64_32_inplace(ulong value, ulong added) + { + ulong x = value + added; + x = (x >> (64 - 32)) | (x << 32); + return x; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong rol64_33(ulong value) + { + return (value >> (64 - 33)) | (value << 33); + } + + [MethodImpl(MethodImplOptions.NoInlining)] ulong rol64field(int amount) { return (field << amount) | (field >> (64 - amount)); @@ -128,12 +154,38 @@ public class Test [MethodImpl(MethodImplOptions.NoInlining)] static ulong ror64const() { - ulong value = flag() ? (ulong)0x123456789abcdef : (ulong)0x123456789abcdef; + ulong value = flag() ? (ulong)0x123456789abcdef : (ulong)0xabcdef123456789; int amount = flag() ? 5 : 5; return (value << (64 - amount)) | (value >> amount); } [MethodImpl(MethodImplOptions.NoInlining)] + static ulong ror64_5(ulong value) + { + return (value << (64 - 5)) | (value >> 5); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong ror64_32(ulong value) + { + return (value << (64 - 32)) | (value >> 32); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong ror64_33(ulong value) + { + return (value << (64 - 33)) | (value >> 33); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong ror64_32_inplace(ulong value, ulong added) + { + ulong x = value + added; + x = (x << (64 - 32)) | (x >> 32); + return x; + } + + [MethodImpl(MethodImplOptions.NoInlining)] static ulong ror64sfield(int amount) { return (s_field << (64 - amount)) | (s_field >> amount); @@ -244,6 +296,26 @@ public class Test return Fail; } + if (rol64_16(0x123456789abcdef) != 0x456789abcdef0123) + { + return Fail; + } + + if (rol64_32(0x123456789abcdef) != rol64(0x123456789abcdef, 32)) + { + return Fail; + } + + if (rol64_33(0x123456789abcdef) != rol64(0x123456789abcdef, 33)) + { + return Fail; + } + + if (rol64_32_inplace(0x123456789abcdef, 0) != rol64(0x123456789abcdef, 32)) + { + return Fail; + } + if (ror64(0x123456789abcdef, 0) != 0x123456789abcdef) { return Fail; @@ -259,6 +331,26 @@ public class Test return Fail; } + if (ror64_5(0x123456789abcdef) != 0x78091a2b3c4d5e6f) + { + return Fail; + } + + if (ror64_32(0x123456789abcdef) != ror64(0x123456789abcdef, 32)) + { + return Fail; + } + + if (ror64_33(0x123456789abcdef) != ror64(0x123456789abcdef, 33)) + { + return Fail; + } + + if (ror64_32_inplace(0x123456789abcdef, 0) != ror64(0x123456789abcdef, 32)) + { + return Fail; + } + if (rol32_call(0x12345678, 16) != 0x56781234) { return Fail; diff --git a/tests/src/JIT/CodeGenBringUpTests/Shift.cs b/tests/src/JIT/CodeGenBringUpTests/Shift.cs new file mode 100644 index 0000000000..085ad3f31f --- /dev/null +++ b/tests/src/JIT/CodeGenBringUpTests/Shift.cs @@ -0,0 +1,86 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + + +using System; +using System.Runtime.CompilerServices; + +public class Test +{ + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong shl64(ulong shift, int count) + { + return shift << count; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong shl64_32_inplace(ulong shift, ulong addit) + { + ulong x = shift + addit; + x = x << 32; + return x; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong shl64_33_inplace(ulong shift, ulong addit) + { + ulong x = shift + addit; + x = x << 33; + return x; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong shr64(ulong shift, int count) + { + return shift >> count; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong shr64_32_inplace(ulong shift, ulong addit) + { + ulong x = shift + addit; + x = x >> 32; + return x; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static ulong shr1_32_add(ulong shift, ulong addit) + { + ulong x = (addit + (shift >> 1)) >> 31; + return x; + } + + public static int Main() + { + const int Pass = 100; + const int Fail = -1; + + if (shl64_32_inplace(0x123456789abcdef, 0) != shl64(0x123456789abcdef, 32)) + { + Console.WriteLine("shl64_32"); + return Fail; + } + + if (shl64_33_inplace(0x123456789abcdef, 0) != shl64(0x123456789abcdef, 33)) + { + Console.WriteLine("shl64_33"); + return Fail; + } + + if (shr64_32_inplace(0x123456789abcdef, 0) != shr64(0x123456789abcdef, 32)) + { + Console.WriteLine("shr64_32 {0:X} {1:X}", shr64_32_inplace(0x123456789abcdef, 0), shr64(0x123456789abcdef, 32)); + return Fail; + } + + if (shr1_32_add(0x123456789abcdef, 0) != shr64(0x123456789abcdef, 32)) + { + Console.WriteLine("HAHAHAHAHAHAHA {0:X}", shr1_32_add(0x123456789abcdef, 0)); + return Fail; + } + + return Pass; + } +} diff --git a/tests/src/JIT/CodeGenBringUpTests/Shift.csproj b/tests/src/JIT/CodeGenBringUpTests/Shift.csproj new file mode 100644 index 0000000000..2189ed3dd5 --- /dev/null +++ b/tests/src/JIT/CodeGenBringUpTests/Shift.csproj @@ -0,0 +1,40 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{AF7F2478-9B49-4776-BEAF-0BF8916E2D79}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <Compile Include="Shift.cs" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs b/tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs new file mode 100644 index 0000000000..26080d8d71 --- /dev/null +++ b/tests/src/JIT/Directed/pinvoke/pinvoke-examples.cs @@ -0,0 +1,223 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// Test cases showing interaction of inlining and inline pinvoke, +// along with the impact of EH. + +using System; +using System.Runtime.CompilerServices; + + +namespace PInvokeTest +{ + internal class Test + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static int AsForceInline() + { + return Environment.ProcessorCount; + } + + static int AsNormalInline() + { + return Environment.ProcessorCount; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int AsNoInline() + { + return Environment.ProcessorCount; + } + + static bool FromTryCatch() + { + bool result = false; + try + { + // All pinvokes should be inline, except on x64 + result = (Environment.ProcessorCount == AsNormalInline()); + } + catch (Exception) + { + result = false; + } + return result; + } + + static bool FromTryFinally() + { + bool result = false; + bool result1 = false; + bool result2 = false; + try + { + // All pinvokes should be inline, except on x64 + result1 = (Environment.ProcessorCount == AsNormalInline()); + result2 = (Environment.ProcessorCount == AsNormalInline()); + } + finally + { + result = result1 && result2; + } + return result; + } + + static bool FromTryFinally2() + { + bool result = false; + bool result1 = false; + bool result2 = false; + + try + { + // These two pinvokes should be inline, except on x64 + result1 = (Environment.ProcessorCount == AsNormalInline()); + } + finally + { + // These two pinvokes should *not* be inline (finally) + result2 = (Environment.ProcessorCount == AsNormalInline()); + result = result1 && result2; + } + + return result; + } + + static bool FromTryFinally3() + { + bool result = false; + bool result1 = false; + bool result2 = false; + + try + { + // These two pinvokes should be inline, except on x64 + result1 = (Environment.ProcessorCount == AsNormalInline()); + } + finally + { + try + { + // These two pinvokes should *not* be inline (finally) + result2 = (Environment.ProcessorCount == AsNormalInline()); + } + catch (Exception) + { + result2 = false; + } + + result = result1 && result2; + } + + return result; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromInline() + { + // These two pinvokes should be inline + bool result = (Environment.ProcessorCount == AsForceInline()); + return result; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromInline2() + { + // These four pinvokes should be inline + bool result1 = (Environment.ProcessorCount == AsNormalInline()); + bool result2 = (Environment.ProcessorCount == AsForceInline()); + return result1 && result2; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromNoInline() + { + // The only pinvoke should be inline + bool result = (Environment.ProcessorCount == AsNoInline()); + return result; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool FromNoInline2() + { + // Three pinvokes should be inline + bool result1 = (Environment.ProcessorCount == AsNormalInline()); + bool result2 = (Environment.ProcessorCount == AsNoInline()); + return result1 && result2; + } + + static bool FromFilter() + { + bool result = false; + + try + { + throw new Exception("expected"); + } + // These two pinvokes should *not* be inline (filter) + // + // For the first call the jit won't inline the wrapper, so + // it just calls get_ProcessorCount. + // + // For the second call, the force inline works, and the + // subsequent inline of get_ProcessorCount exposes a call + // to the pinvoke GetProcessorCount. This pinvoke will + // not be inline. + catch (Exception) when (Environment.ProcessorCount == AsForceInline()) + { + result = true; + } + + return result; + } + + static bool FromColdCode() + { + int pc = 0; + bool result1 = false; + bool result2 = false; + + try + { + // This pinvoke should not be inline (cold) + pc = Environment.ProcessorCount; + throw new Exception("expected"); + } + catch (Exception) + { + // These two pinvokes should not be inline (catch) + // + // For the first call the jit won't inline the + // wrapper, so it just calls get_ProcessorCount. + // + // For the second call, the force inline works, and + // the subsequent inline of get_ProcessorCount exposes + // a call to the pinvoke GetProcessorCount. This + // pinvoke will not be inline. + result1 = (pc == Environment.ProcessorCount); + result2 = (pc == AsForceInline()); + } + + return result1 && result2; + } + + private static int Main() + { + bool result = true; + + result &= FromTryCatch(); + result &= FromTryFinally(); + result &= FromTryFinally2(); + result &= FromTryFinally3(); + result &= FromInline(); + result &= FromInline2(); + result &= FromNoInline(); + result &= FromNoInline2(); + result &= FromFilter(); + result &= FromColdCode(); + + return (result ? 100 : -1); + } + } +} diff --git a/tests/src/JIT/Directed/pinvoke/pinvoke-examples.csproj b/tests/src/JIT/Directed/pinvoke/pinvoke-examples.csproj new file mode 100644 index 0000000000..78cf4471fe --- /dev/null +++ b/tests/src/JIT/Directed/pinvoke/pinvoke-examples.csproj @@ -0,0 +1,44 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>PdbOnly</DebugType> + </PropertyGroup> + <ItemGroup> + <Compile Include="pinvoke-examples.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project>
\ No newline at end of file diff --git a/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_d.csproj b/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_d.csproj index fed9ead2ac..a4054021e7 100644 --- a/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_d.csproj +++ b/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_d.csproj @@ -14,6 +14,9 @@ <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + + <!-- NOTE: this test simply takes too long to complete under GC stress; it is not fundamentally incompatible --> + <GCStressIncompatible Condition="'$(Platform)' == 'x86'">true</GCStressIncompatible> </PropertyGroup> <!-- Default configurations to help VS understand the configurations --> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> @@ -43,4 +46,4 @@ <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> </PropertyGroup> -</Project>
\ No newline at end of file +</Project> diff --git a/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_r.csproj b/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_r.csproj index 7d311bfb47..bd5ae97d4b 100644 --- a/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_r.csproj +++ b/tests/src/JIT/Methodical/fp/exgen/10w5d_cs_r.csproj @@ -14,6 +14,9 @@ <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + + <!-- NOTE: this test simply takes too long to complete under GC stress; it is not fundamentally incompatible --> + <GCStressIncompatible Condition="'$(Platform)' == 'x86'">true</GCStressIncompatible> </PropertyGroup> <!-- Default configurations to help VS understand the configurations --> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> @@ -43,4 +46,4 @@ <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> </PropertyGroup> -</Project>
\ No newline at end of file +</Project> diff --git a/tests/src/JIT/Methodical/structs/systemvbringup/structpinvoketests.cs b/tests/src/JIT/Methodical/structs/systemvbringup/structpinvoketests.cs index 7fc52039e5..8eae60686f 100644 --- a/tests/src/JIT/Methodical/structs/systemvbringup/structpinvoketests.cs +++ b/tests/src/JIT/Methodical/structs/systemvbringup/structpinvoketests.cs @@ -364,650 +364,698 @@ namespace structinreg s1.y = 2; s1.z = 3; s1.w = 4; - - InvokeCallback1((par) => { - Console.WriteLine("S1: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) - { - throw new System.Exception(); - } - }, s1); - S2 s2; - s2.x = 1; - s2.y = 2; - s2.z = 3; - InvokeCallback2((par) => { - Console.WriteLine("S2: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + try + { + InvokeCallback1((par) => { - throw new System.Exception(); - } - }, s2); - - S3 s3; - s3.x = 1; - s3.y = 2; - s3.z = 3; - InvokeCallback3((par) => { - Console.WriteLine("S3: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + Console.WriteLine("S1: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s1); + + S2 s2; + s2.x = 1; + s2.y = 2; + s2.z = 3; + InvokeCallback2((par) => { - throw new System.Exception(); - } - }, s3); - - S4 s4; - s4.x = 1; - s4.y = 2; - InvokeCallback4((par) => { - Console.WriteLine("S4: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + Console.WriteLine("S2: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s2); + + S3 s3; + s3.x = 1; + s3.y = 2; + s3.z = 3; + InvokeCallback3((par) => { - throw new System.Exception(); - } - }, s4); - - S5 s5; - s5.x = 1; - s5.y = 2; - InvokeCallback5((par) => { - Console.WriteLine("S5: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + Console.WriteLine("S3: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s3); + + S4 s4; + s4.x = 1; + s4.y = 2; + InvokeCallback4((par) => { - throw new System.Exception(); - } - }, s5); - - S6 s6; - s6.x = 1; - s6.y = 2; - s6.z = 3; - s6.w = 4; - InvokeCallback6((par) => { - Console.WriteLine("S6: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + Console.WriteLine("S4: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s4); + + S5 s5; + s5.x = 1; + s5.y = 2; + InvokeCallback5((par) => { - throw new System.Exception(); - } - }, s6); - - S7 s7; - s7.x = 1; - s7.y = 2; - s7.z = 3; - InvokeCallback7((par) => { - Console.WriteLine("S7: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + Console.WriteLine("S5: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s5); + + S6 s6; + s6.x = 1; + s6.y = 2; + s6.z = 3; + s6.w = 4; + InvokeCallback6((par) => { - throw new System.Exception(); - } - }, s7); - - S8 s8; - s8.x = 1; - s8.y = 2; - InvokeCallback8((par) => { - Console.WriteLine("S8: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + Console.WriteLine("S6: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s6); + + S7 s7; + s7.x = 1; + s7.y = 2; + s7.z = 3; + InvokeCallback7((par) => { - throw new System.Exception(); - } - }, s8); - - S9 s9; - s9.x = 1; - s9.y = 2; - s9.z = 3; - s9.w = 4; - InvokeCallback9((par) => { - Console.WriteLine("S9: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + Console.WriteLine("S7: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s7); + + S8 s8; + s8.x = 1; + s8.y = 2; + InvokeCallback8((par) => { - throw new System.Exception(); - } - }, s9); - - S10 s10; - s10.a = 1; - s10.b = 2; - s10.c = 3; - s10.d = 4; - s10.e = 5; - s10.f = 6; - s10.g = 7; - s10.h = 8; - InvokeCallback10((par) => { - Console.WriteLine("S10: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || - par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8) + Console.WriteLine("S8: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s8); + + S9 s9; + s9.x = 1; + s9.y = 2; + s9.z = 3; + s9.w = 4; + InvokeCallback9((par) => { - throw new System.Exception(); - } - }, s10); - - S11 s11; - s11.a = 1; - s11.b = 2; - s11.c = 3; - s11.d = 4; - s11.e = 5; - InvokeCallback11((par) => { - Console.WriteLine("S11: {0}, {1}, {2}, {3}, {4}", par.a, par.b, par.c, par.d, par.e); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || par.e != 5) + Console.WriteLine("S9: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s9); + + S10 s10; + s10.a = 1; + s10.b = 2; + s10.c = 3; + s10.d = 4; + s10.e = 5; + s10.f = 6; + s10.g = 7; + s10.h = 8; + InvokeCallback10((par) => { - throw new System.Exception(); - } - }, s11); - - S12 s12; - s12.a = 1; - s12.b = 2; - s12.c = 3; - s12.d = 4; - s12.e = 5; - s12.f = 6; - s12.g = 7; - s12.h = 8; - s12.i = 9; - InvokeCallback12((par) => { - Console.WriteLine("S12: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || - par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + Console.WriteLine("S10: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || + par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8) + { + throw new System.Exception(); + } + }, s10); + + S11 s11; + s11.a = 1; + s11.b = 2; + s11.c = 3; + s11.d = 4; + s11.e = 5; + InvokeCallback11((par) => { - throw new System.Exception(); - } - }, s12); - - S13 s13; - s13.hasValue = 1; - s13.x = 2; - InvokeCallback13((par) => { - Console.WriteLine("S13: {0}, {1}", par.hasValue, par.x); - if (par.hasValue != 1 || par.x != 2) + Console.WriteLine("S11: {0}, {1}, {2}, {3}, {4}", par.a, par.b, par.c, par.d, par.e); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || par.e != 5) + { + throw new System.Exception(); + } + }, s11); + + S12 s12; + s12.a = 1; + s12.b = 2; + s12.c = 3; + s12.d = 4; + s12.e = 5; + s12.f = 6; + s12.g = 7; + s12.h = 8; + s12.i = 9; + InvokeCallback12((par) => { - throw new System.Exception(); - } - }, s13); - - S14 s14; - s14.x = 1; - s14.y = 2; - InvokeCallback14((par) => { - Console.WriteLine("S14: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + Console.WriteLine("S12: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || + par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + { + throw new System.Exception(); + } + }, s12); + + S13 s13; + s13.hasValue = 1; + s13.x = 2; + InvokeCallback13((par) => { - throw new System.Exception(); - } - }, s14); - - S15 s15; - s15.a = 1; - s15.b = 2; - s15.c = 3; - s15.d = 4; - s15.e = 5; - s15.f = 6; - s15.g = 7; - s15.h = 8; - s15.i = 9; - InvokeCallback15((par) => { - Console.WriteLine("S15: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || - par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + Console.WriteLine("S13: {0}, {1}", par.hasValue, par.x); + if (par.hasValue != 1 || par.x != 2) + { + throw new System.Exception(); + } + }, s13); + + S14 s14; + s14.x = 1; + s14.y = 2; + InvokeCallback14((par) => { - throw new System.Exception(); - } - }, s15); - - S16 s16; - s16.x = 1; - s16.y = 2; - InvokeCallback16((par) => { - Console.WriteLine("S16: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + Console.WriteLine("S14: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s14); + + S15 s15; + s15.a = 1; + s15.b = 2; + s15.c = 3; + s15.d = 4; + s15.e = 5; + s15.f = 6; + s15.g = 7; + s15.h = 8; + s15.i = 9; + InvokeCallback15((par) => { - throw new System.Exception(); - } - }, s16); - - S17 s17; - s17.x = 1; - s17.y = 2; - InvokeCallback17((par) => { - Console.WriteLine("S17: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + Console.WriteLine("S15: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || + par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + { + throw new System.Exception(); + } + }, s15); + + S16 s16; + s16.x = 1; + s16.y = 2; + InvokeCallback16((par) => { - throw new System.Exception(); - } - }, s17); - - S18 s18; - s18.x = 1; - s18.y = 2; - s18.z = 3; - InvokeCallback18((par) => { - Console.WriteLine("S18: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + Console.WriteLine("S16: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s16); + + S17 s17; + s17.x = 1; + s17.y = 2; + InvokeCallback17((par) => { - throw new System.Exception(); - } - }, s18); - - S19 s19; - s19.x = 1; - s19.y = 2; - s19.z = 3; - s19.w = 4; - InvokeCallback19((par) => { - Console.WriteLine("S19: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + Console.WriteLine("S17: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s17); + + S18 s18; + s18.x = 1; + s18.y = 2; + s18.z = 3; + InvokeCallback18((par) => { - throw new System.Exception(); - } - }, s19); - - S20 s20; - s20.x = 1; - s20.y = 2; - s20.z = 3; - s20.w = 4; - InvokeCallback20((par) => { - Console.WriteLine("S20: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + Console.WriteLine("S18: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s18); + + S19 s19; + s19.x = 1; + s19.y = 2; + s19.z = 3; + s19.w = 4; + InvokeCallback19((par) => { - throw new System.Exception(); - } - }, s20); - -/* These tests are not working on non Windows CoreCLR. Enable this when GH Issue #2076 is resolved. - TestClass testClass = new TestClass(); - S28 s28; - s28.x = null; - s28.y = 1; - - InvokeCallback28((par) => { - Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); - if (par.x != null || par.y != 1) + Console.WriteLine("S19: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s19); + + S20 s20; + s20.x = 1; + s20.y = 2; + s20.z = 3; + s20.w = 4; + InvokeCallback20((par) => { - throw new System.Exception(); - } - }, s28); - - s28.x = testClass; - s28.y = 5; - - InvokeCallback28((par) => { - Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); - if (par.x != testClass || par.y != 5) + Console.WriteLine("S20: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s20); + + /* These tests are not working on non Windows CoreCLR. Enable this when GH Issue #2076 is resolved. + TestClass testClass = new TestClass(); + S28 s28; + s28.x = null; + s28.y = 1; + + InvokeCallback28((par) => { + Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); + if (par.x != null || par.y != 1) + { + throw new System.Exception(); + } + }, s28); + + s28.x = testClass; + s28.y = 5; + + InvokeCallback28((par) => { + Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); + if (par.x != testClass || par.y != 5) + { + throw new System.Exception(); + } + }, s28); + + S29 s29; + s29.x = 1; + s29.y = null; + + InvokeCallback29((par) => { + Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); + if (par.x != 1 || par.y != null) + { + throw new System.Exception(); + } + }, s29); + + s29.x = 5; + s29.y = testClass; + + InvokeCallback29((par) => { + Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); + if (par.x != 5 || par.y != testClass) + { + throw new System.Exception(); + } + }, s29); + Enable this when GH Issue #2076 is resolved. */ + S30 s30; + s30.x = 1; + s30.y = 2; + + S30 s30_2; + s30_2.x = 3; + s30_2.y = 4; + + S30 s30_3; + s30_3.x = 5; + s30_3.y = 6; + + // Program p = new Program(); + InvokeCallback30(p.Test30, s30, s30_2, s30_3); + S1 s1r = InvokeCallback1R((par) => { - throw new System.Exception(); - } - }, s28); - - S29 s29; - s29.x = 1; - s29.y = null; - - InvokeCallback29((par) => { - Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); - if (par.x != 1 || par.y != null) + Console.WriteLine("S1: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + + }, s1); + Console.WriteLine("S1R: {0}, {1}, {2}, {3}", s1r.x, s1r.y, s1r.z, s1r.w); + if (s1r.x != 1 || s1r.y != 2 || s1r.z != 3 || s1r.w != 4) { throw new System.Exception(); } - }, s29); - s29.x = 5; - s29.y = testClass; - - InvokeCallback29((par) => { - Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); - if (par.x != 5 || par.y != testClass) + S2 s2r = InvokeCallback2R((par) => { - throw new System.Exception(); - } - }, s29); - Enable this when GH Issue #2076 is resolved. */ - S30 s30; - s30.x = 1; - s30.y = 2; - - S30 s30_2; - s30_2.x = 3; - s30_2.y = 4; - - S30 s30_3; - s30_3.x = 5; - s30_3.y = 6; - - // Program p = new Program(); - InvokeCallback30(p.Test30, s30, s30_2, s30_3); - S1 s1r = InvokeCallback1R((par) => { - Console.WriteLine("S1: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + Console.WriteLine("S2: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s2); + Console.WriteLine("S2R: {0}, {1}, {2}", s2r.x, s2r.y, s2r.z); + if (s2r.x != 1 || s2r.y != 2 || s2r.z != 3) { throw new System.Exception(); } - }, s1); - Console.WriteLine("S1R: {0}, {1}, {2}, {3}", s1r.x, s1r.y, s1r.z, s1r.w); - if (s1r.x != 1 || s1r.y != 2 || s1r.z != 3 || s1r.w != 4) - { - throw new System.Exception(); - } - - S2 s2r = InvokeCallback2R((par) => { - Console.WriteLine("S2: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + S3 s3r = InvokeCallback3R((par) => + { + Console.WriteLine("S3: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s3); + Console.WriteLine("S3R: {0}, {1}, {2}", s3r.x, s3r.y, s3r.z); + if (s3r.x != 1 || s3r.y != 2 || s3r.z != 3) { throw new System.Exception(); } - }, s2); - Console.WriteLine("S2R: {0}, {1}, {2}", s2r.x, s2r.y, s2r.z); - if (s2r.x != 1 || s2r.y != 2 || s2r.z != 3) - { - throw new System.Exception(); - } - S3 s3r = InvokeCallback3R((par) => { - Console.WriteLine("S3: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + S4 s4r = InvokeCallback4R((par) => + { + Console.WriteLine("S4: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s4); + Console.WriteLine("S4R: {0}, {1}", s4r.x, s4r.y); + if (s4r.x != 1 || s4r.y != 2) { throw new System.Exception(); } - }, s3); - Console.WriteLine("S3R: {0}, {1}, {2}", s3r.x, s3r.y, s3r.z); - if (s3r.x != 1 || s3r.y != 2 || s3r.z != 3) - { - throw new System.Exception(); - } - S4 s4r = InvokeCallback4R((par) => { - Console.WriteLine("S4: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + S5 s5r = InvokeCallback5R((par) => + { + Console.WriteLine("S5: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s5); + Console.WriteLine("S5R: {0}, {1}", s5r.x, s5r.y); + if (s5r.x != 1 || s5r.y != 2) { throw new System.Exception(); } - }, s4); - Console.WriteLine("S4R: {0}, {1}", s4r.x, s4r.y); - if (s4r.x != 1 || s4r.y != 2) - { - throw new System.Exception(); - } - S5 s5r = InvokeCallback5R((par) => { - Console.WriteLine("S5: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + S6 s6r = InvokeCallback6R((par) => + { + Console.WriteLine("S6: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s6); + Console.WriteLine("S6R: {0}, {1}, {2}, {3}", s6r.x, s6r.y, s6r.z, s6r.w); + if (s6r.x != 1 || s6r.y != 2 || s6r.z != 3 || s6r.w != 4) { throw new System.Exception(); } - }, s5); - Console.WriteLine("S5R: {0}, {1}", s5r.x, s5r.y); - if (s5r.x != 1 || s5r.y != 2) - { - throw new System.Exception(); - } - S6 s6r = InvokeCallback6R((par) => { - Console.WriteLine("S6: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + S7 s7r = InvokeCallback7R((par) => + { + Console.WriteLine("S7: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s7); + Console.WriteLine("S7R: {0}, {1}, {2}", s7r.x, s7r.y, s7r.z); + if (s7r.x != 1 || s7r.y != 2 || s7r.z != 3) { throw new System.Exception(); } - }, s6); - Console.WriteLine("S6R: {0}, {1}, {2}, {3}", s6r.x, s6r.y, s6r.z, s6r.w); - if (s6r.x != 1 || s6r.y != 2 || s6r.z != 3 || s6r.w != 4) - { - throw new System.Exception(); - } - S7 s7r = InvokeCallback7R((par) => { - Console.WriteLine("S7: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + S8 s8r = InvokeCallback8R((par) => + { + Console.WriteLine("S8: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s8); + Console.WriteLine("S8R: {0}, {1}", s8r.x, s8r.y); + if (s8r.x != 1 || s8r.y != 2) { throw new System.Exception(); } - }, s7); - Console.WriteLine("S7R: {0}, {1}, {2}", s7r.x, s7r.y, s7r.z); - if (s7r.x != 1 || s7r.y != 2 || s7r.z != 3) - { - throw new System.Exception(); - } - S8 s8r = InvokeCallback8R((par) => { - Console.WriteLine("S8: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + S9 s9r = InvokeCallback9R((par) => + { + Console.WriteLine("S9: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s9); + Console.WriteLine("S9R: {0}, {1}, {2}, {3}", s9r.x, s9r.y, s9r.z, s9r.w); + if (s9r.x != 1 || s9r.y != 2 || s9r.z != 3 || s9r.w != 4) { throw new System.Exception(); } - }, s8); - Console.WriteLine("S8R: {0}, {1}", s8r.x, s8r.y); - if (s8r.x != 1 || s8r.y != 2) - { - throw new System.Exception(); - } - S9 s9r = InvokeCallback9R((par) => { - Console.WriteLine("S9: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + S10 s10r = InvokeCallback10R((par) => { - throw new System.Exception(); - } - }, s9); - Console.WriteLine("S9R: {0}, {1}, {2}, {3}", s9r.x, s9r.y, s9r.z, s9r.w); - if (s9r.x != 1 || s9r.y != 2 || s9r.z != 3 || s9r.w != 4) - { - throw new System.Exception(); - } - - S10 s10r = InvokeCallback10R((par) => { - Console.WriteLine("S10: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || - par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8) + Console.WriteLine("S10: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || + par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8) + { + throw new System.Exception(); + } + }, s10); + Console.WriteLine("S10R: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}", s10r.a, s10r.b, s10r.c, s10r.d, s10r.e, s10r.f, s10r.g, s10r.h); + if (s10r.a != 1 || s10r.b != 2 || s10r.c != 3 || s10r.d != 4 || + s10r.e != 5 || s10r.f != 6 || s10r.g != 7 || s10r.h != 8) { throw new System.Exception(); } - }, s10); - Console.WriteLine("S10R: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}", s10r.a, s10r.b, s10r.c, s10r.d, s10r.e, s10r.f, s10r.g, s10r.h); - if (s10r.a != 1 || s10r.b != 2 || s10r.c != 3 || s10r.d != 4 || - s10r.e != 5 || s10r.f != 6 || s10r.g != 7 || s10r.h != 8) - { - throw new System.Exception(); - } - S11 s11r = InvokeCallback11R((par) => { - Console.WriteLine("S11: {0}, {1}, {2}, {3}, {4}", par.a, par.b, par.c, par.d, par.e); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || par.e != 5) + S11 s11r = InvokeCallback11R((par) => + { + Console.WriteLine("S11: {0}, {1}, {2}, {3}, {4}", par.a, par.b, par.c, par.d, par.e); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || par.e != 5) + { + throw new System.Exception(); + } + }, s11); + Console.WriteLine("S11R: {0}, {1}, {2}, {3}, {4}", s11r.a, s11r.b, s11r.c, s11r.d, s11r.e); + if (s11r.a != 1 || s11r.b != 2 || s11r.c != 3 || s11r.d != 4 || s11r.e != 5) { throw new System.Exception(); } - }, s11); - Console.WriteLine("S11R: {0}, {1}, {2}, {3}, {4}", s11r.a, s11r.b, s11r.c, s11r.d, s11r.e); - if (s11r.a != 1 || s11r.b != 2 || s11r.c != 3 || s11r.d != 4 || s11r.e != 5) - { - throw new System.Exception(); - } - S12 s12r = InvokeCallback12R((par) => { - Console.WriteLine("S12: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || - par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + S12 s12r = InvokeCallback12R((par) => + { + Console.WriteLine("S12: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || + par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + { + throw new System.Exception(); + } + }, s12); + Console.WriteLine("S12R: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", s12r.a, s12r.b, s12r.c, s12r.d, s12r.e, s12r.f, s12r.g, s12r.h, s12r.i); + if (s12r.a != 1 || s12r.b != 2 || s12r.c != 3 || s12r.d != 4 || + s12r.e != 5 || s12r.f != 6 || s12r.g != 7 || s12r.h != 8 || s12r.i != 9) { throw new System.Exception(); } - }, s12); - Console.WriteLine("S12R: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", s12r.a, s12r.b, s12r.c, s12r.d, s12r.e, s12r.f, s12r.g, s12r.h, s12r.i); - if (s12r.a != 1 || s12r.b != 2 || s12r.c != 3 || s12r.d != 4 || - s12r.e != 5 || s12r.f != 6 || s12r.g != 7 || s12r.h != 8 || s12r.i != 9) - { - throw new System.Exception(); - } - S13 s13r = InvokeCallback13R((par) => { - Console.WriteLine("S13: {0}, {1}", par.hasValue, par.x); - if (par.hasValue != 1 || par.x != 2) + S13 s13r = InvokeCallback13R((par) => + { + Console.WriteLine("S13: {0}, {1}", par.hasValue, par.x); + if (par.hasValue != 1 || par.x != 2) + { + throw new System.Exception(); + } + }, s13); + Console.WriteLine("S13R: {0}, {1}", s13r.hasValue, s13r.x); + if (s13r.hasValue != 1 || s13r.x != 2) { throw new System.Exception(); } - }, s13); - Console.WriteLine("S13R: {0}, {1}", s13r.hasValue, s13r.x); - if (s13r.hasValue != 1 || s13r.x != 2) - { - throw new System.Exception(); - } - S14 s14r = InvokeCallback14R((par) => { - Console.WriteLine("S14: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + S14 s14r = InvokeCallback14R((par) => + { + Console.WriteLine("S14: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s14); + Console.WriteLine("S14R: {0}, {1}", s14r.x, s14r.y); + if (s14r.x != 1 || s14r.y != 2) { throw new System.Exception(); } - }, s14); - Console.WriteLine("S14R: {0}, {1}", s14r.x, s14r.y); - if (s14r.x != 1 || s14r.y != 2) - { - throw new System.Exception(); - } - S15 s15r = InvokeCallback15R((par) => { - Console.WriteLine("S15: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); - if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || - par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + S15 s15r = InvokeCallback15R((par) => + { + Console.WriteLine("S15: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", par.a, par.b, par.c, par.d, par.e, par.f, par.g, par.h, par.i); + if (par.a != 1 || par.b != 2 || par.c != 3 || par.d != 4 || + par.e != 5 || par.f != 6 || par.g != 7 || par.h != 8 || par.i != 9) + { + throw new System.Exception(); + } + }, s15); + Console.WriteLine("S15R: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", s15r.a, s15r.b, s15r.c, s15r.d, s15r.e, s15r.f, s15r.g, s15r.h, s15r.i); + if (s15r.a != 1 || s15r.b != 2 || s15r.c != 3 || s15r.d != 4 || + s15r.e != 5 || s15r.f != 6 || s15r.g != 7 || s15r.h != 8 || s15r.i != 9) { throw new System.Exception(); } - }, s15); - Console.WriteLine("S15R: {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", s15r.a, s15r.b, s15r.c, s15r.d, s15r.e, s15r.f, s15r.g, s15r.h, s15r.i); - if (s15r.a != 1 || s15r.b != 2 || s15r.c != 3 || s15r.d != 4 || - s15r.e != 5 || s15r.f != 6 || s15r.g != 7 || s15r.h != 8 || s15r.i != 9) - { - throw new System.Exception(); - } - S16 s16r = InvokeCallback16R((par) => { - Console.WriteLine("S16: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y != 2) + S16 s16r = InvokeCallback16R((par) => + { + Console.WriteLine("S16: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s16); + Console.WriteLine("S16R: {0}, {1}", s16r.x, s16r.y); + if (s16r.x != 1 || s16r.y != 2) { throw new System.Exception(); } - }, s16); - Console.WriteLine("S16R: {0}, {1}", s16r.x, s16r.y); - if (s16r.x != 1 || s16r.y != 2) - { - throw new System.Exception(); - } - S17 s17r = InvokeCallback17R((par) => { - Console.WriteLine("S17: {0}, {1}", par.x, par.y); - if (par.x != 1 || par.y!= 2) + S17 s17r = InvokeCallback17R((par) => + { + Console.WriteLine("S17: {0}, {1}", par.x, par.y); + if (par.x != 1 || par.y != 2) + { + throw new System.Exception(); + } + }, s17); + Console.WriteLine("S17R: {0}, {1}", s17r.x, s17r.y); + if (s17r.x != 1 || s17r.y != 2) { throw new System.Exception(); } - }, s17); - Console.WriteLine("S17R: {0}, {1}", s17r.x, s17r.y); - if (s17r.x != 1 || s17r.y != 2) - { - throw new System.Exception(); - } - S18 s18r = InvokeCallback18R((par) => { - Console.WriteLine("S18: {0}, {1}, {2}", par.x, par.y, par.z); - if (par.x != 1 || par.y != 2 || par.z != 3) + S18 s18r = InvokeCallback18R((par) => + { + Console.WriteLine("S18: {0}, {1}, {2}", par.x, par.y, par.z); + if (par.x != 1 || par.y != 2 || par.z != 3) + { + throw new System.Exception(); + } + }, s18); + Console.WriteLine("S18R: {0}, {1}, {2}", s18r.x, s18r.y, s18r.z); + if (s18r.x != 1 || s18r.y != 2 || s18r.z != 3) { throw new System.Exception(); } - }, s18); - Console.WriteLine("S18R: {0}, {1}, {2}", s18r.x, s18r.y, s18r.z); - if (s18r.x != 1 || s18r.y != 2 || s18r.z != 3) - { - throw new System.Exception(); - } - S19 s19r = InvokeCallback19R((par) => { - Console.WriteLine("S19: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + S19 s19r = InvokeCallback19R((par) => + { + Console.WriteLine("S19: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s19); + Console.WriteLine("S19R: {0}, {1}, {2}, {3}", s19r.x, s19r.y, s19r.z, s19r.w); + if (s19r.x != 1 || s19r.y != 2 || s19r.z != 3 || s19r.w != 4) { throw new System.Exception(); } - }, s19); - Console.WriteLine("S19R: {0}, {1}, {2}, {3}", s19r.x, s19r.y, s19r.z, s19r.w); - if (s19r.x != 1 || s19r.y != 2 || s19r.z != 3 || s19r.w != 4) - { - throw new System.Exception(); - } - S20 s20r = InvokeCallback20R((par) => { - Console.WriteLine("S20: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); - if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + S20 s20r = InvokeCallback20R((par) => + { + Console.WriteLine("S20: {0}, {1}, {2}, {3}", par.x, par.y, par.z, par.w); + if (par.x != 1 || par.y != 2 || par.z != 3 || par.w != 4) + { + throw new System.Exception(); + } + }, s20); + Console.WriteLine("S20R: {0}, {1}, {2}, {3}", s20r.x, s20r.y, s20r.z, s20r.w); + if (s20r.x != 1 || s20r.y != 2 || s20r.z != 3 || s20r.w != 4) { throw new System.Exception(); } - }, s20); - Console.WriteLine("S20R: {0}, {1}, {2}, {3}", s20r.x, s20r.y, s20r.z, s20r.w); - if (s20r.x != 1 || s20r.y != 2 || s20r.z != 3 || s20r.w != 4) - { - throw new System.Exception(); - } -/* These tests are not working on non Windows CoreCLR. Enable this when GH Issue #2076 is resolved. - s28.x = null; - S28 s28r = InvokeCallback28R((par) => { - Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); - if (par.x == null || par.y != 5) + /* These tests are not working on non Windows CoreCLR. Enable this when GH Issue #2076 is resolved. + s28.x = null; + S28 s28r = InvokeCallback28R((par) => { + Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); + if (par.x == null || par.y != 5) + { + throw new System.Exception(); + } + }, s28); + Console.WriteLine("S28R: {0}, {1}", s28r.x == null ? "Null" : "Not null", s28r.y); + if (s28r.x == null || s28r.y != 5) { throw new System.Exception(); } - }, s28); - Console.WriteLine("S28R: {0}, {1}", s28r.x == null ? "Null" : "Not null", s28r.y); - if (s28r.x == null || s28r.y != 5) - { - throw new System.Exception(); - } - s28.x = testClass; - s28.y = 5; - - s28r = InvokeCallback28R((par) => { - Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); - if (par.x != testClass || par.y != 5) + s28.x = testClass; + s28.y = 5; + + s28r = InvokeCallback28R((par) => { + Console.WriteLine("S28: {0}, {1}", par.x == null ? "Null" : "Not null", par.y); + if (par.x != testClass || par.y != 5) + { + throw new System.Exception(); + } + }, s28); + Console.WriteLine("S28R: {0}, {1}", s28r.x == null ? "Null" : "Not null", s28r.y); + if (s28r.x != testClass || s28r.y != 5) { throw new System.Exception(); } - }, s28); - Console.WriteLine("S28R: {0}, {1}", s28r.x == null ? "Null" : "Not null", s28r.y); - if (s28r.x != testClass || s28r.y != 5) - { - throw new System.Exception(); - } - s29.y = null; - S29 s29r = InvokeCallback29R((par) => { - Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); - if (par.x != 5 || par.y == null) + s29.y = null; + S29 s29r = InvokeCallback29R((par) => { + Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); + if (par.x != 5 || par.y == null) + { + throw new System.Exception(); + } + }, s29); + Console.WriteLine("S29R: {0}, {1}", s29r.x, s29r.y == null ? "Null" : "Not null"); + if (s29r.x != 5 || s29r.y == null) { throw new System.Exception(); } - }, s29); - Console.WriteLine("S29R: {0}, {1}", s29r.x, s29r.y == null ? "Null" : "Not null"); - if (s29r.x != 5 || s29r.y == null) - { - throw new System.Exception(); - } - s29.x = 5; - s29.y = testClass; - s29r = InvokeCallback29R((par) => { - Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); - if (par.x != 5 || par.y != testClass) + s29.x = 5; + s29.y = testClass; + s29r = InvokeCallback29R((par) => { + Console.WriteLine("S29: {0}, {1}", par.x, par.y == null ? "Null" : "Not null"); + if (par.x != 5 || par.y != testClass) + { + throw new System.Exception(); + } + }, s29); + Console.WriteLine("S29R: {0}, {1}", s29r.x, s29r.y == null ? "Null" : "Not null"); + if (s29r.x != 5 || s29r.y != testClass) { throw new System.Exception(); } - }, s29); - Console.WriteLine("S29R: {0}, {1}", s29r.x, s29r.y == null ? "Null" : "Not null"); - if (s29r.x != 5 || s29r.y != testClass) + Enable this when GH Issue #2076 is resolved. */ + } + catch (Exception e) { - throw new System.Exception(); + Console.WriteLine(e.Message); + return -1; } - Enable this when GH Issue #2076 is resolved. */ return 100; } diff --git a/tests/src/JIT/Methodical/structs/valuetuple.cs b/tests/src/JIT/Methodical/structs/valuetuple.cs new file mode 100644 index 0000000000..9e8af5e20c --- /dev/null +++ b/tests/src/JIT/Methodical/structs/valuetuple.cs @@ -0,0 +1,95 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +// This test is extracted and simplified from the corefx tests for the ValueTuple class. +// It exposed an issue with assertion propagation not validating the assertions +// for a containing struct when a field lclVar is defined. + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Runtime.InteropServices; + +[StructLayout(LayoutKind.Auto)] +public struct ValueTuple<T1, T2, T3> +{ + public T1 Item1; + public T2 Item2; + public T3 Item3; + public ValueTuple(T1 item1, T2 item2, T3 item3) + { + Item1 = item1; + Item2 = item2; + Item3 = item3; + } + + public static ValueTuple<T1, T2, T3> Create(T1 item1, T2 item2, T3 item3) => + new ValueTuple<T1, T2, T3>(item1, item2, item3); + + public override bool Equals(object obj) + { + return obj is ValueTuple<T1, T2, T3> && Equals((ValueTuple<T1, T2, T3>)obj); + } + + public bool Equals(ValueTuple<T1, T2, T3> other) + { + return Item1.Equals(other.Item1) && Item2.Equals(other.Item2) && Item3.Equals(other.Item3); + } + public override int GetHashCode() + { + return 0; + } +} + +public static class TupleExtensions +{ + public static ValueTuple<T1, T2, T3> + ToValueTuple<T1, T2, T3>( + this Tuple<T1, T2, T3> value) + { + return ValueTuple<T1, T2, T3>.Create(value.Item1, value.Item2, value.Item3); + } + public static Tuple<T1, T2, T3> + ToTuple<T1, T2, T3>( + this ValueTuple<T1, T2, T3> value) + { + return Tuple.Create(value.Item1, value.Item2, value.Item3); + } +} + +public class StructOptsTest +{ + const int Pass = 100; + const int Fail = -1; + + public static int ConvertToRef3() + { + var refTuple = Tuple.Create(-1, -1, -1); + var valueTuple = ValueTuple<int,int,int>.Create(1, 2, 3); + + refTuple = valueTuple.ToTuple(); + if (!String.Equals("(1, 2, 3)", refTuple.ToString())) + { + Console.WriteLine("Expected (1, 2, 3); got " + refTuple.ToString()); + return Fail; + } + return Pass; + } + + public static int Main() + { + int returnVal = Fail; + try + { + returnVal = ConvertToRef3(); + } + catch (Exception e) + { + Console.WriteLine("Unexpected exception " + e.Message); + returnVal = Fail; + } + return returnVal; + } +} diff --git a/tests/src/JIT/Methodical/structs/valuetuple.csproj b/tests/src/JIT/Methodical/structs/valuetuple.csproj new file mode 100644 index 0000000000..486744bb36 --- /dev/null +++ b/tests/src/JIT/Methodical/structs/valuetuple.csproj @@ -0,0 +1,41 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{0B8F1AF4-9355-4307-BC68-08A2947AD3B9}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + <IlasmRoundTrip>true</IlasmRoundTrip> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <Compile Include="valuetuple.cs" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Adams/Adams.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Adams/Adams.cs index 427ec9269e..431d857f16 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Adams/Adams.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Adams/Adams.cs @@ -18,6 +18,8 @@ using Microsoft.Xunit.Performance; [assembly: MeasureInstructionsRetired] #endif // XUNIT_PERF +namespace Benchstone.BenchF +{ public static class Adams { #if DEBUG @@ -41,7 +43,7 @@ public static class Adams #if VERBOSE Console.WriteLine(" ADAMS-MOULTON METHOD "); -#endif // VERBOSE +#endif // VERBOSE n = 4; h = 1.0 / 32.0; @@ -67,7 +69,7 @@ public static class Adams f[i] = xn + yn; #if VERBOSE Console.WriteLine("{0}, {1}, {2}, {3}, {4}", k, xn, yn, dn, en); -#endif // VERBOSE +#endif // VERBOSE } for (k = 4; k <= nstep; k++) @@ -137,7 +139,7 @@ public static class Adams bool result = true; // Note: we can't check xn or yn better because of the precision - // with which original results are given + // with which original results are given result &= System.Math.Abs(g_xn_base - g_xn) <= 1.5e-7; result &= System.Math.Abs(g_yn_base - g_yn) <= 1.5e-7; result &= System.Math.Abs(g_dn) <= 2.5e-9; @@ -161,3 +163,4 @@ public static class Adams return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMk2/BenchMk2.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMk2/BenchMk2.cs index 970164405b..c4cfc0b217 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMk2/BenchMk2.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMk2/BenchMk2.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class BenchMk2 { #if DEBUG @@ -64,3 +66,4 @@ public static class BenchMk2 return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMrk/BenchMrk.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMrk/BenchMrk.cs index 27a5fe617c..f342b2d84e 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMrk/BenchMrk.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/BenchMrk/BenchMrk.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class BenchMrk { #if DEBUG @@ -64,3 +66,4 @@ public static class BenchMrk return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Bisect/Bisect.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Bisect/Bisect.cs index 1c27003567..724416a626 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Bisect/Bisect.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Bisect/Bisect.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Bisect { #if DEBUG @@ -161,3 +163,4 @@ public static class Bisect return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/DMath/DMath.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/DMath/DMath.cs index a2c3a385cd..47c5e20285 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/DMath/DMath.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/DMath/DMath.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class DMath { #if DEBUG @@ -110,4 +112,5 @@ public static class DMath return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/FFT/FFT.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/FFT/FFT.cs index 3e853273fb..8881eae6c6 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/FFT/FFT.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/FFT/FFT.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class FFT { #if DEBUG @@ -151,3 +153,4 @@ public static class FFT return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/InProd/InProd.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/InProd/InProd.cs index ff54ea7acd..26096b736e 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/InProd/InProd.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/InProd/InProd.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class InProd { #if DEBUG @@ -132,3 +134,4 @@ public static class InProd return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/InvMt/InvMt.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/InvMt/InvMt.cs index a5f387b7f5..6ecfb62d91 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/InvMt/InvMt.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/InvMt/InvMt.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class InvMt { #if DEBUG @@ -135,3 +137,4 @@ public static class InvMt return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/LLoops/LLoops.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/LLoops/LLoops.cs index 6dcb6c435c..73ec09aa04 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/LLoops/LLoops.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/LLoops/LLoops.cs @@ -60,6 +60,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public class LLoops { #if DEBUG @@ -648,3 +650,4 @@ public class LLoops return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Lorenz/Lorenz.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Lorenz/Lorenz.cs index bff6398d3b..5819446bf0 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Lorenz/Lorenz.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Lorenz/Lorenz.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Lorenz { #if DEBUG @@ -132,3 +134,4 @@ public static class Lorenz return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/MatInv4/MatInv4.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/MatInv4/MatInv4.cs index eb5e33b130..a00c29b843 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/MatInv4/MatInv4.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/MatInv4/MatInv4.cs @@ -10,6 +10,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class MatInv4 { #if DEBUG @@ -217,11 +219,11 @@ public static class MatInv4 // 0 < ik <= n^2 ik = nk + i; hold = a[ik - 1]; - // -n < ij <= 0 + // -n < ij <= 0 ij = i - n; for (j = 1; j <= n; ++j) { - // i <= n, ij <= n + n + ... + n (n times) or ij <= n * n + // i <= n, ij <= n + n + ... + n (n times) or ij <= n * n ij = ij + n; if (j == k) { @@ -237,7 +239,7 @@ public static class MatInv4 kj = k - n; for (j = 1; j <= n; ++j) { - // k <= n, kj <= n + n + ... + n (n times) or kj <= n * n + // k <= n, kj <= n + n + ... + n (n times) or kj <= n * n kj = kj + n; if (j == k) { @@ -268,11 +270,11 @@ public static class MatInv4 jr = n * (i - 1); for (j = 1; j <= n; ++j) { - // jk <= n^2 - n + n + // jk <= n^2 - n + n // jk <= n^2 jk = jq + j; hold = a[jk - 1]; - // ji <= n^2 - n + n + // ji <= n^2 - n + n // ji <= n^2 ji = jr + j; a[jk - 1] = -a[ji - 1]; @@ -288,7 +290,7 @@ public static class MatInv4 ki = k - n; for (i = 1; i <= n; ++i) { - // ki <= n + n + ... + n (n times) or ki <= n * n + // ki <= n + n + ... + n (n times) or ki <= n * n ki = ki + n; hold = a[ki - 1]; // if i=1, ji = (1 + (n-1) * n) - 1 + n ==> ij = n^2 @@ -378,7 +380,7 @@ public static class MatInv4 { if (j != k) { - // Accessing upto n^2 - n + n - 1 ==> n^2 - 1 + // Accessing upto n^2 - n + n - 1 ==> n^2 - 1 a[(i - 1) * n + (j - 1)] = a[(i - 1) * n + (k - 1)] * a[(k - 1) * n + (j - 1)] + a[(i - 1) * n + (j - 1)]; } } @@ -493,3 +495,4 @@ public static class MatInv4 return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/NewtE/NewtE.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/NewtE/NewtE.cs index 0fc14132f1..47f90d8616 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/NewtE/NewtE.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/NewtE/NewtE.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class NewtE { #if DEBUG @@ -133,3 +135,4 @@ public static class NewtE return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/NewtR/NewtR.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/NewtR/NewtR.cs index cf945bc110..c590f6e570 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/NewtR/NewtR.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/NewtR/NewtR.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class NewtR { #if DEBUG @@ -129,3 +131,4 @@ public static class NewtR return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Regula/Regula.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Regula/Regula.cs index 9743ab698c..0011288e55 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Regula/Regula.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Regula/Regula.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Regula { #if DEBUG @@ -191,3 +193,4 @@ public static class Regula return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Romber/Romber.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Romber/Romber.cs index 5824cd43cc..a4d56f7b0f 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Romber/Romber.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Romber/Romber.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Romber { #if DEBUG @@ -167,3 +169,4 @@ public static class Romber return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Secant/Secant.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Secant/Secant.cs index e7d1ace2e6..060fb5b0a4 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Secant/Secant.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Secant/Secant.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Secant { #if DEBUG @@ -140,3 +142,4 @@ public static class Secant return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Simpsn/Simpsn.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Simpsn/Simpsn.cs index e1e9f0eb1f..5b2df292af 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Simpsn/Simpsn.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Simpsn/Simpsn.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Simpsn { #if DEBUG @@ -91,3 +93,4 @@ public static class Simpsn return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/SqMtx/SqMtx.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/SqMtx/SqMtx.cs index 673757cedf..b22aad88b7 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/SqMtx/SqMtx.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/SqMtx/SqMtx.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class SqMtx { #if DEBUG @@ -101,3 +103,4 @@ public static class SqMtx return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Trap/Trap.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Trap/Trap.cs index a5e3e5c0d6..3a0de102ed 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Trap/Trap.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Trap/Trap.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Trap { #if DEBUG @@ -94,3 +96,4 @@ public static class Trap return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchF/Whetsto/Whetsto.cs b/tests/src/JIT/Performance/CodeQuality/BenchF/Whetsto/Whetsto.cs index 2ab0b61ee0..ffe3fa5d8b 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchF/Whetsto/Whetsto.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchF/Whetsto/Whetsto.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchF +{ public static class Whetsto { #if DEBUG @@ -240,3 +242,4 @@ public static class Whetsto return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/8Queens/8Queens.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/8Queens/8Queens.cs index 76ed0c8e71..e641ee0a74 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/8Queens/8Queens.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/8Queens/8Queens.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class EightQueens { @@ -68,7 +70,7 @@ public static class EightQueens } i = i + 1; } - + TryMe(1, ref q, b, a); return (q == 1); @@ -92,9 +94,10 @@ public static class EightQueens } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Ackermann/Ackermann.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Ackermann/Ackermann.cs index 512f35f82d..5bfa196527 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Ackermann/Ackermann.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Ackermann/Ackermann.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class Ackermann { @@ -40,7 +42,7 @@ public static class Ackermann int a33 = Acker(3, 3); return (a00 == 1) && (a11 == 3) && (a22 == 7) & (a33 == 61); } - + [Benchmark] public static void Test() { foreach (var iteration in Benchmark.Iterations) { @@ -59,9 +61,10 @@ public static class Ackermann } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray/AddArray.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray/AddArray.cs index 0fa2ff90eb..d38e6b4475 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray/AddArray.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray/AddArray.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class AddArray { @@ -48,14 +50,14 @@ public static class AddArray m = j; flags4[m] = flags3[l] + m + m + m + m; } - + for (j = 0; j <= Size; j++) { k = j; l = j; m = j; flags1[j] = flags1[j] + flags2[k] + flags3[l] + flags4[m] - flags2[k - j + l]; } - + // Escape each flags array so that their elements will appear live-out Escape(flags1); Escape(flags2); @@ -83,9 +85,10 @@ public static class AddArray } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray2/AddArray2.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray2/AddArray2.cs index 865b9445f6..a6004f0309 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray2/AddArray2.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/AddArray2/AddArray2.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class AddArray2 { #if DEBUG @@ -129,3 +131,4 @@ public static class AddArray2 return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Array1/Array1.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Array1/Array1.cs index 8d5dbd6153..780b7ce66f 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Array1/Array1.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Array1/Array1.cs @@ -18,6 +18,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class Array1 { #if DEBUG @@ -152,3 +154,4 @@ public static class Array1 return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Array2/Array2.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Array2/Array2.cs index 1b720b94fa..dac100c5a7 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Array2/Array2.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Array2/Array2.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class Array2 { @@ -75,7 +77,7 @@ public static class Array2 } bool result = VerifyCopy(s, d); - + return result; } @@ -92,9 +94,10 @@ public static class Array2 bool result = Bench(Iterations); return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/BenchE/BenchE.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/BenchE/BenchE.cs index 9cf7d770dc..b16c48280b 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/BenchE/BenchE.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/BenchE/BenchE.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class BenchE { #if DEBUG @@ -115,3 +117,4 @@ public static class BenchE return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort/BubbleSort.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort/BubbleSort.cs index 78626fffc9..558484d3d6 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort/BubbleSort.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort/BubbleSort.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class BubbleSort { @@ -43,7 +45,7 @@ public static class BubbleSort return false; } } - + return true; } @@ -79,9 +81,10 @@ public static class BubbleSort } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort2/BubbleSort2.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort2/BubbleSort2.cs index 55e5a5f8c5..8c2e63a954 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort2/BubbleSort2.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/BubbleSort2/BubbleSort2.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class BubbleSort2 { @@ -82,9 +84,10 @@ public static class BubbleSort2 } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/CSieve/CSieve.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/CSieve/CSieve.cs index 606f740fb6..aca263711d 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/CSieve/CSieve.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/CSieve/CSieve.cs @@ -12,6 +12,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class CSieve { @@ -74,9 +76,10 @@ public static class CSieve } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Fib/Fib.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Fib/Fib.cs index 01064bb168..ee028db20f 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Fib/Fib.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Fib/Fib.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class Fib { @@ -30,7 +32,7 @@ public static class Fib return 1; } } - + [MethodImpl(MethodImplOptions.NoInlining)] static bool Bench() { int fib = Fibonacci(Number); @@ -55,9 +57,10 @@ public static class Fib } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/HeapSort/HeapSort.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/HeapSort/HeapSort.cs index 9fd7aa32e0..64b5c8f33b 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/HeapSort/HeapSort.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/HeapSort/HeapSort.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class HeapSort { @@ -32,7 +34,7 @@ public static class HeapSort j = i; k = j / 2; m = x[i]; - + // 0 < k <= (n / 2) // 1 <= j <= n while (k > 0) { @@ -113,9 +115,10 @@ public static class HeapSort } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/IniArray/IniArray.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/IniArray/IniArray.cs index 78fa233dbf..268af7b779 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/IniArray/IniArray.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/IniArray/IniArray.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class IniArray { @@ -52,9 +54,10 @@ public static class IniArray bool result = Bench(); return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/LogicArray/LogicArray.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/LogicArray/LogicArray.cs index f5ff746b86..c5b4e3b0d8 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/LogicArray/LogicArray.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/LogicArray/LogicArray.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class LogicArray { @@ -89,9 +91,10 @@ public static class LogicArray bool result = Bench(); return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Midpoint/Midpoint.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Midpoint/Midpoint.cs index 6e4f193746..9146874358 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Midpoint/Midpoint.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Midpoint/Midpoint.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class Midpoint { @@ -96,9 +98,10 @@ public static class Midpoint bool result = Bench(); return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/MulMatrix/MulMatrix.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/MulMatrix/MulMatrix.cs index 3f9c224d3d..a45c012984 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/MulMatrix/MulMatrix.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/MulMatrix/MulMatrix.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class MulMatrix { @@ -19,7 +21,7 @@ public static class MulMatrix #else public const int Iterations = 100; #endif - + const int Size = 75; static volatile object VolatileObject; @@ -132,9 +134,10 @@ public static class MulMatrix bool result = Bench(); return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/NDhrystone/NDhrystone.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/NDhrystone/NDhrystone.cs index c2526748ce..33effcbf40 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/NDhrystone/NDhrystone.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/NDhrystone/NDhrystone.cs @@ -7,7 +7,7 @@ // Dhrystone: a synthetic systems programming benchmark // Reinhold P. Weicker // Communications of the ACM, Volume 27 Issue 10, Oct 1984, Pages 1013-1030 - + using Microsoft.Xunit.Performance; using System; using System.Runtime.CompilerServices; @@ -16,6 +16,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class NDhrystone { @@ -63,9 +65,9 @@ public static class NDhrystone int intLoc2; int intLoc3 = 0; Enumeration enumLoc; - + int i; /* modification */ - + m_ptrGlb.PtrComp = m_ptrGlbNext; m_ptrGlb.Discr = Enumeration.Ident1; m_ptrGlb.EnumComp = Enumeration.Ident3; @@ -117,12 +119,12 @@ public static class NDhrystone ptrParIn = ptrParIn.PtrComp; } } - + static void Proc2(ref int intParIO) { int intLoc; Enumeration enumLoc = Enumeration.Ident2; intLoc = intParIO + 10; - + for (;;) { if (s_char1Glob == 'A') { --intLoc; @@ -142,17 +144,17 @@ public static class NDhrystone else { s_intGlob = 100; } - + Proc7(10, s_intGlob, ref m_ptrGlb.IntComp); } - + static void Proc4() { bool boolLoc; boolLoc = s_char1Glob == 'A'; boolLoc |= s_boolGlob; s_char2Glob = 'B'; } - + static void Proc5() { s_char1Glob = 'A'; s_boolGlob = false; @@ -163,12 +165,12 @@ public static class NDhrystone if (!Func3(enumParIn)) { enumParOut = Enumeration.Ident4; } - + switch (enumParIn) { - case Enumeration.Ident1: + case Enumeration.Ident1: enumParOut = Enumeration.Ident1; break; - case Enumeration.Ident2: + case Enumeration.Ident2: if (s_intGlob > 100) { enumParOut = Enumeration.Ident1; } @@ -176,12 +178,12 @@ public static class NDhrystone enumParOut = Enumeration.Ident4; } break; - case Enumeration.Ident3: + case Enumeration.Ident3: enumParOut = Enumeration.Ident2; break; - case Enumeration.Ident4: + case Enumeration.Ident4: break; - case Enumeration.Ident5: + case Enumeration.Ident5: enumParOut = Enumeration.Ident3; break; } @@ -192,7 +194,7 @@ public static class NDhrystone intLoc = intParI1 + 2; intParOut = intParI2 + intLoc; } - + static void Proc8(int[] array1Par, int[][] array2Par, int intParI1, int intParI2) { int intLoc; intLoc = intParI1 + 5; @@ -206,7 +208,7 @@ public static class NDhrystone array2Par[intLoc + 20][intLoc] = array1Par[intLoc]; s_intGlob = 5; } - + static Enumeration Func1(char charPar1, char charPar2) { char charLoc1; char charLoc2; @@ -219,7 +221,7 @@ public static class NDhrystone return (Enumeration.Ident2); } } - + static bool Func2(char[] strParI1, char[] strParI2) { int intLoc; char charLoc = '\0'; @@ -243,18 +245,18 @@ public static class NDhrystone return true; } } - + return false; } } - + static bool Func3(Enumeration enumParIn) { Enumeration enumLoc; enumLoc = enumParIn; if (enumLoc == Enumeration.Ident3) { return true; } - + return false; } @@ -278,9 +280,10 @@ public static class NDhrystone bool result = Bench(); return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Permutate/Permutate.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Permutate/Permutate.cs index d7457cdbc1..43fc28b370 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Permutate/Permutate.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Permutate/Permutate.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public class Permutate { #if DEBUG @@ -114,3 +116,4 @@ public class Permutate return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Pi/Pi.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Pi/Pi.cs index 112ff6df9b..2fe0918784 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Pi/Pi.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Pi/Pi.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class Pi { @@ -78,9 +80,10 @@ public static class Pi } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/Puzzle/Puzzle.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/Puzzle/Puzzle.cs index 2b1c2847f4..2271e02455 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/Puzzle/Puzzle.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/Puzzle/Puzzle.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public class Puzzle { #if DEBUG @@ -391,3 +393,4 @@ public class Puzzle return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/QuickSort/QuickSort.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/QuickSort/QuickSort.cs index 191211aaa8..7cdac96a69 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/QuickSort/QuickSort.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/QuickSort/QuickSort.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class QuickSort { @@ -52,7 +54,7 @@ public static class QuickSort arr[j] = temp; } } - + // need to swap the pivot and a[i](or a[j] as i==j) so // that the pivot will be at its final place in the sorted array @@ -108,9 +110,10 @@ public static class QuickSort } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/TreeInsert/TreeInsert.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/TreeInsert/TreeInsert.cs index 8a24240538..2867abc4d4 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/TreeInsert/TreeInsert.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/TreeInsert/TreeInsert.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public class TreeInsert { #if DEBUG @@ -136,3 +138,4 @@ public class TreeInsert return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/TreeSort/TreeSort.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/TreeSort/TreeSort.cs index 68b5c965f7..e0971346cf 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/TreeSort/TreeSort.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/TreeSort/TreeSort.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class TreeSort { @@ -74,7 +76,7 @@ public static class TreeSort else { Insert(n, t.Left); } - } + } else if (n < t.Val) { if (t.Right == null) { t.Right = new Node(n); @@ -117,7 +119,7 @@ public static class TreeSort bool result = CheckTree(tree); return result; } - + [MethodImpl(MethodImplOptions.NoInlining)] static bool Bench() { int[] sortList = new int[SortElements + 1]; @@ -143,9 +145,10 @@ public static class TreeSort } return result; } - + public static int Main() { bool result = TestBase(); return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchI/XposMatrix/XposMatrix.cs b/tests/src/JIT/Performance/CodeQuality/BenchI/XposMatrix/XposMatrix.cs index 0bb17b8cc5..de8b486049 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchI/XposMatrix/XposMatrix.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchI/XposMatrix/XposMatrix.cs @@ -11,6 +11,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Benchstone.BenchI +{ public static class XposMatrix { public const int ArraySize = 100; @@ -48,11 +50,11 @@ public static class XposMatrix matrix[i][j] = 1; } } - + if (matrix[n][n] != 1) { return false; } - + Inner(matrix, n); if (matrix[n][n] != 1) { @@ -88,3 +90,4 @@ public static class XposMatrix return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/binarytrees/binarytrees.csharp.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/binarytrees/binarytrees.csharp.cs index e4118b2963..c77e802989 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/binarytrees/binarytrees.csharp.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/binarytrees/binarytrees.csharp.cs @@ -2,9 +2,9 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. /* The Computer Language Benchmarks Game - http://benchmarksgame.alioth.debian.org/ + http://benchmarksgame.alioth.debian.org/ - contributed by Marek Safar + contributed by Marek Safar modified for use with xunit-performance */ @@ -17,6 +17,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace BenchmarksGame +{ public class BinaryTrees { private const int minDepth = 4; @@ -149,3 +151,4 @@ public class BinaryTrees return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fasta/fasta.csharp-2.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fasta/fasta.csharp-2.cs index c58ce0bd97..92fbceb692 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fasta/fasta.csharp-2.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fasta/fasta.csharp-2.cs @@ -18,6 +18,8 @@ using System.Text; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace BenchmarksGame +{ public class Fasta { #if DEBUG @@ -218,3 +220,4 @@ public class Fasta s.Write(s_buf, 0, s_index); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fastaredux/fastaredux.csharp.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fastaredux/fastaredux.csharp.cs index 7128e326fc..df8999a2de 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fastaredux/fastaredux.csharp.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/fastaredux/fastaredux.csharp.cs @@ -18,6 +18,8 @@ using System.Text; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace BenchmarksGame +{ public static class FastaRedux { #if DEBUG @@ -181,4 +183,5 @@ public static class FastaRedux if (br < BUF_LEN) s.Write(s_buf, 0, BUF_LEN - br); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/nbody/nbody.csharp-3.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/nbody/nbody.csharp-3.cs index 70c87095ad..2124cf4d9e 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/nbody/nbody.csharp-3.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/nbody/nbody.csharp-3.cs @@ -15,6 +15,8 @@ using System; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace BenchmarksGame +{ public class NBody { public static int Main(String[] args) @@ -153,4 +155,5 @@ internal class NBodySystem return e; } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/pidigits/pi-digits.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/pidigits/pi-digits.cs index 3395e29a55..7e36f0e424 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/pidigits/pi-digits.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/pidigits/pi-digits.cs @@ -6,7 +6,7 @@ * * Port of the C code that uses GMP * Just switched it to use C#'s BigInteger instead - * + * * To compile use csc /o+ /r:System.Numerics.dll * * modified for use with xunit-performance @@ -20,6 +20,8 @@ using System.Text; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace BenchmarksGame +{ public class pidigits { #if DEBUG @@ -111,4 +113,5 @@ public class pidigits } } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/spectralnorm/spectralnorm.cs b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/spectralnorm/spectralnorm.cs index 9e984864a7..01eeea07bf 100644 --- a/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/spectralnorm/spectralnorm.cs +++ b/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/spectralnorm/spectralnorm.cs @@ -3,8 +3,8 @@ // See the LICENSE file in the project root for more information. /* The Computer Language Benchmarks Game http://benchmarksgame.alioth.debian.org/ - - contributed by Isaac Gouy + + contributed by Isaac Gouy modified for use with xunit-performance */ @@ -15,6 +15,8 @@ using System; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace BenchmarksGame +{ public class SpectralNorm { #if DEBUG @@ -78,7 +80,7 @@ public class SpectralNorm } // B=AtA A multiplied by A transposed - // v.Bv /(v.v) eigenvalue of v + // v.Bv /(v.v) eigenvalue of v double vBv = 0, vv = 0; for (int i = 0; i < n; i++) { @@ -124,3 +126,4 @@ public class SpectralNorm MultiplyAtv(n, u, AtAv); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsByte.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsByte.cs index 8271c40a43..3b28f87fe5 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsByte.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsByte.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsByte { @@ -928,3 +930,4 @@ public static class ConstantArgsByte return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsChar.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsChar.cs index 0d1f9284ba..0cc4b9c558 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsChar.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsChar.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsChar { @@ -928,3 +930,4 @@ public static class ConstantArgsChar return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsDouble.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsDouble.cs index 6c95d482d5..4bd5683f0c 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsDouble.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsDouble { @@ -808,3 +810,4 @@ public static class ConstantArgsDouble return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsFloat.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsFloat.cs index bbd65a4004..f609a4bb44 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsFloat.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsFloat.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsFloat { @@ -808,3 +810,4 @@ public static class ConstantArgsFloat return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsInt.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsInt.cs index 03d59f93d0..f54e800d17 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsInt.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsInt.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsInt { @@ -928,3 +930,4 @@ public static class ConstantArgsInt return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsLong.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsLong.cs index f4e45f50db..e5679f1638 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsLong.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsLong.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsLong { @@ -928,3 +930,4 @@ public static class ConstantArgsLong return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsSByte.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsSByte.cs index b329122967..0ec29b8341 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsSByte.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsSByte.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsSByte { @@ -928,3 +930,4 @@ public static class ConstantArgsSByte return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsShort.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsShort.cs index 8718111a72..f8cf23e8da 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsShort.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsShort.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsShort { @@ -928,3 +930,4 @@ public static class ConstantArgsShort return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsString.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsString.cs index b7319086d7..38a3f7e6b9 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsString.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsString.cs @@ -16,6 +16,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsString { @@ -328,3 +330,4 @@ public static class ConstantArgsString return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUInt.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUInt.cs index db3316ea32..e3f6e2aae8 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUInt.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUInt.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsUInt { @@ -888,3 +890,4 @@ public static class ConstantArgsUInt return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsULong.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsULong.cs index 72087077e2..7585a3e1fc 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsULong.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsULong.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsULong { @@ -888,3 +890,4 @@ public static class ConstantArgsULong return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUShort.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUShort.cs index 249e985496..c96274e424 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUShort.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/ConstantArgsUShort.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class ConstantArgsUShort { @@ -928,3 +930,4 @@ public static class ConstantArgsUShort return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.cs new file mode 100644 index 0000000000..660627cc72 --- /dev/null +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.cs @@ -0,0 +1,148 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// In CoreCLR String.Format(ref, ref) is small and readily inlined. +// The inline introduces a System.Parms GC struct local which is +// untracked and must be zero initialized in the prolog. When the +// inlined callsite is in a cold path, the inline hurts performance. +// +// There are two test methods below, one of which calls String.Format +// on a cold path and the other which has similar structure but +// does not call String.Format. Expectation is that they will have +// similar performance. +// +// See https://github.com/dotnet/coreclr/issues/7569 for context. + +using Microsoft.Xunit.Performance; +using System; +using System.Runtime.CompilerServices; +using Xunit; + +[assembly: OptimizeForBenchmarks] +[assembly: MeasureInstructionsRetired] + +namespace Inlining +{ +public class InlineGCStruct +{ +#if DEBUG + public const int Iterations = 1; +#else + public const int Iterations = 2500000; +#endif + + [MethodImpl(MethodImplOptions.NoInlining)] + public static int FastFunctionNotCallingStringFormat(int param) + { + if (param < 0) + { + throw new Exception(String.Format("We do not like the value {0:N0}.", param)); + } + + if (param == int.MaxValue) + { + throw new Exception(String.Format("{0:N0} is maxed out.", param)); + } + + if (param > int.MaxValue / 2) + { + throw new Exception(String.Format("We do not like the value {0:N0} either.", param)); + } + + return param * 2; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static int FastFunctionNotHavingStringFormat(int param) + { + if (param < 0) + { + throw new ArgumentOutOfRangeException("param", "We do not like this value."); + } + + if (param == int.MaxValue) + { + throw new ArgumentOutOfRangeException("param", "Maxed out."); + } + + if (param > int.MaxValue / 2) + { + throw new ArgumentOutOfRangeException("param", "We do not like this value either."); + } + + return param * 2; + } + + [Benchmark] + public static bool WithFormat() + { + int result = 0; + + foreach (var iteration in Benchmark.Iterations) + { + using (iteration.StartMeasurement()) + { + for (int i = 0; i < Iterations; i++) + { + result |= FastFunctionNotCallingStringFormat(11); + } + } + } + + return (result == 22); + } + + [Benchmark] + public static bool WithoutFormat() + { + int result = 0; + + foreach (var iteration in Benchmark.Iterations) + { + using (iteration.StartMeasurement()) + { + for (int i = 0; i < Iterations; i++) + { + result |= FastFunctionNotHavingStringFormat(11); + } + } + } + + return (result == 22); + } + + public static bool WithoutFormatBase() + { + int result = 0; + + for (int i = 0; i < Iterations; i++) + { + result |= FastFunctionNotHavingStringFormat(11); + } + + return (result == 22); + } + + public static bool WithFormatBase() + { + int result = 0; + + for (int i = 0; i < Iterations; i++) + { + result |= FastFunctionNotCallingStringFormat(11); + } + + return (result == 22); + } + + public static int Main() + { + bool withFormat = WithFormatBase(); + bool withoutFormat = WithoutFormatBase(); + + return (withFormat && withoutFormat ? 100 : -1); + } +} +} + diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.csproj b/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.csproj new file mode 100644 index 0000000000..cb3381638c --- /dev/null +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.csproj @@ -0,0 +1,44 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <Compile Include="InlineGCStruct.cs" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs index 9b689ce376..dc05f44b33 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs @@ -13,6 +13,8 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Inlining +{ public static class NoThrowInline { #if DEBUG @@ -34,7 +36,7 @@ public static class NoThrowInline // // We expect ThrowArgumentNullException to not be inlined into Bench, the throw code is pretty - // large and throws are extremly slow. However, we need to be careful not to degrade the + // large and throws are extremly slow. However, we need to be careful not to degrade the // non-exception path performance by preserving registers across the call. For this the compiler // will have to understand that ThrowArgumentNullException never returns and omit the register // preservation code. @@ -73,3 +75,4 @@ public static class NoThrowInline return (Bench("a", "bc", "def", "ghij") == 10) ? 100 : -1; } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/SIMD/ConsoleMandel/ConsoleMandel.cs b/tests/src/JIT/Performance/CodeQuality/SIMD/ConsoleMandel/ConsoleMandel.cs index ed7f675700..5ab08202b6 100644 --- a/tests/src/JIT/Performance/CodeQuality/SIMD/ConsoleMandel/ConsoleMandel.cs +++ b/tests/src/JIT/Performance/CodeQuality/SIMD/ConsoleMandel/ConsoleMandel.cs @@ -11,9 +11,9 @@ using Xunit; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] -namespace ConsoleMandel +namespace SIMD { - public static class Program + public static class ConsoleMandel { private const int Pass = 100; private const int Fail = -1; diff --git a/tests/src/JIT/Performance/CodeQuality/SIMD/RayTracer/RayTracerBench.cs b/tests/src/JIT/Performance/CodeQuality/SIMD/RayTracer/RayTracerBench.cs index 064f860611..254672b462 100644 --- a/tests/src/JIT/Performance/CodeQuality/SIMD/RayTracer/RayTracerBench.cs +++ b/tests/src/JIT/Performance/CodeQuality/SIMD/RayTracer/RayTracerBench.cs @@ -2,8 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. // -// Based on the Raytracer example from -// Samples for Parallel Programming with the .NET Framework +// Based on the Raytracer example from +// Samples for Parallel Programming with the .NET Framework // https://code.msdn.microsoft.com/windowsdesktop/Samples-for-Parallel-b4b76364 using Microsoft.Xunit.Performance; @@ -16,6 +16,8 @@ using System.Collections.Concurrent; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace SIMD +{ public class RayTracerBench { #if DEBUG @@ -142,3 +144,4 @@ public class RayTracerBench return (result ? 100 : -1); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/SIMD/SeekUnroll/SeekUnroll.cs b/tests/src/JIT/Performance/CodeQuality/SIMD/SeekUnroll/SeekUnroll.cs new file mode 100644 index 0000000000..34c0ab888d --- /dev/null +++ b/tests/src/JIT/Performance/CodeQuality/SIMD/SeekUnroll/SeekUnroll.cs @@ -0,0 +1,159 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using Microsoft.Xunit.Performance; +using System; +using System.Numerics; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Reflection; +using System.Collections.Generic; +using Xunit; + +[assembly: OptimizeForBenchmarks] +[assembly: MeasureInstructionsRetired] + +public static class SeekUnroll +{ + + // The purpose of this micro-benchmark is to measure the effect of unrolling + // on this loop (taken from https://github.com/aspnet/KestrelHttpServer/pull/1138) + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static int FindByte(ref Vector<byte> byteEquals) + { + var vector64 = Vector.AsVectorInt64(byteEquals); + long longValue = 0; + var i = 0; + for (; i < Vector<long>.Count; i++) + { + longValue = vector64[i]; + if (longValue == 0) continue; + break; + } + + // Flag least significant power of two bit + var powerOfTwoFlag = (ulong)(longValue ^ (longValue - 1)); + // Shift all powers of two into the high byte and extract + var foundByteIndex = (int)((powerOfTwoFlag * _xorPowerOfTwoToHighByte) >> 57); + // Single LEA instruction with jitted const (using function result) + return i * 8 + foundByteIndex; + } + + // Magic constant used in FindByte + const ulong _xorPowerOfTwoToHighByte = (0x07ul | + 0x06ul << 8 | + 0x05ul << 16 | + 0x04ul << 24 | + 0x03ul << 32 | + 0x02ul << 40 | + 0x01ul << 48) + 1; + + // Inner loop to repeatedly call FindByte + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static void InnerLoop(ref int foundIndex, ref Vector<Byte> vector) + { + for (int i = 0; i < InnerIterations; i++) + { + foundIndex = FindByte(ref vector); + } + } + + // Iteration counts for inner loop set to have each call take 1 or + // 2 seconds or so in release, finish quickly in debug. +#if DEBUG + const int InnerIterations = 1; +#else + const int InnerIterations = 1000000000; +#endif + + // Function to meaure InnerLoop using the xunit-perf benchmark measurement facilities + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static void XunitBenchmarkLoop(ref int foundIndex, ref Vector<Byte> vector) + { + foreach (var iteration in Benchmark.Iterations) + { + using (iteration.StartMeasurement()) + { + InnerLoop(ref foundIndex, ref vector); + } + } + } + + // Function to measure InnerLoop with manual use of a stopwatch timer + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static void ManualTimerLoop(ref int foundIndex, ref Vector<Byte> vector) + { + for (int iteration = 0; iteration < ManualLoopTimes.Length; ++iteration) + { + var timer = System.Diagnostics.Stopwatch.StartNew(); + InnerLoop(ref foundIndex, ref vector); + timer.Stop(); + ManualLoopTimes[iteration] = timer.ElapsedMilliseconds; + } + } + static long[] ManualLoopTimes; + + // Function that tests one input, dispatching to either the xunit-perf + // loop or the manual timer loop + static bool Test(int index, bool isXunitBenchmark) + { + if (index >= Vector<Byte>.Count) + { + // FindByte assumes index is in range + index = 0; + } + var bytes = new Byte[Vector<Byte>.Count]; + bytes[index] = 255; + Vector<Byte> vector = new Vector<Byte>(bytes); + + int foundIndex = -1; + + if (isXunitBenchmark) + { + XunitBenchmarkLoop(ref foundIndex, ref vector); + } + else + { + ManualTimerLoop(ref foundIndex, ref vector); + } + + Assert.Equal(index, foundIndex); + return (index == foundIndex); + } + + // Set of indices to pass to Test(int, bool) + static int[] IndicesToTest = new int[] { 1, 3, 11, 19, 27 }; + + // Entrypoint for xunit-perf to call the benchmark + [Benchmark] + [MemberData(nameof(ArrayedBoxedIndicesToTest))] + public static bool Test(object boxedIndex) + { + return Test((int)boxedIndex, true); + } + + // IndicesToTest wrapped up in arrays of boxes since that's + // what xunit-perf needs + public static IEnumerable<object[]> ArrayedBoxedIndicesToTest = + IndicesToTest.Select((int index) => new object[] { index }); + + + // Main method entrypoint runs the manual timer loop + public static int Main() + { + int failures = 0; + foreach(int index in IndicesToTest) + { + ManualLoopTimes = new long[10]; + bool passed = Test(index, false); + if (!passed) + { + ++failures; + } + Console.WriteLine("Index {0}, times (ms) [{1}]", index, String.Join(", ", ManualLoopTimes)); + } + + return 100 + failures; + } +} diff --git a/tests/src/JIT/Performance/CodeQuality/SIMD/SeekUnroll/SeekUnroll.csproj b/tests/src/JIT/Performance/CodeQuality/SIMD/SeekUnroll/SeekUnroll.csproj new file mode 100644 index 0000000000..53cfe42001 --- /dev/null +++ b/tests/src/JIT/Performance/CodeQuality/SIMD/SeekUnroll/SeekUnroll.csproj @@ -0,0 +1,43 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{9AE6E18D-B3F9-4216-9809-125824387175}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <Compile Include="SeekUnroll.cs" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Performance/CodeQuality/Serialization/Deserialize.cs b/tests/src/JIT/Performance/CodeQuality/Serialization/Deserialize.cs index b0ed00d40b..56fc2665ad 100644 --- a/tests/src/JIT/Performance/CodeQuality/Serialization/Deserialize.cs +++ b/tests/src/JIT/Performance/CodeQuality/Serialization/Deserialize.cs @@ -15,6 +15,8 @@ using Microsoft.Xunit.Performance; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Serialization +{ public class JsonBenchmarks { @@ -26,7 +28,7 @@ public class JsonBenchmarks public const int JsonNetIterations = 90000; #endif - const string DataContractXml = @"<JsonBenchmarks.TestObject xmlns=""http://schemas.datacontract.org/2004/07/"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""><Id>33</Id><Name>SqMtx</Name><Results xmlns:a=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><a:double>101.3</a:double><a:double>99.8</a:double><a:double>99.6</a:double><a:double>100.4</a:double></Results><WhenRun>2015-01-01T00:00:00-08:00</WhenRun></JsonBenchmarks.TestObject>"; + const string DataContractXml = @"<JsonBenchmarks.TestObject xmlns=""http://schemas.datacontract.org/2004/07/Serialization"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""><Id>33</Id><Name>SqMtx</Name><Results xmlns:a=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><a:double>101.3</a:double><a:double>99.8</a:double><a:double>99.6</a:double><a:double>100.4</a:double></Results><WhenRun>2015-01-01T00:00:00-08:00</WhenRun></JsonBenchmarks.TestObject>"; const string DataContractJson = @"{""Id"":33,""Name"":""SqMtx"",""Results"":[101.3,99.8,99.6,100.4],""WhenRun"":""\/Date(1420099200000-0800)\/""}"; @@ -83,7 +85,7 @@ public class JsonBenchmarks } [Benchmark] - private void DeserializeDataContract() + private void DeserializeDataContract() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { @@ -199,3 +201,4 @@ public class JsonBenchmarks return result ? 100 : -1; } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/Serialization/Serialize.cs b/tests/src/JIT/Performance/CodeQuality/Serialization/Serialize.cs index 905cf56584..39ab5876c9 100644 --- a/tests/src/JIT/Performance/CodeQuality/Serialization/Serialize.cs +++ b/tests/src/JIT/Performance/CodeQuality/Serialization/Serialize.cs @@ -14,6 +14,8 @@ using Microsoft.Xunit.Performance; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] +namespace Serialization +{ public class JsonBenchmarks { @@ -72,7 +74,7 @@ public class JsonBenchmarks } [Benchmark] - private void SerializeDataContract() + private void SerializeDataContract() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { @@ -186,3 +188,4 @@ public class JsonBenchmarks return result ? 100 : -1; } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/V8/Crypto/Crypto.cs b/tests/src/JIT/Performance/CodeQuality/V8/Crypto/Crypto.cs index 23eab8db5b..620e012848 100644 --- a/tests/src/JIT/Performance/CodeQuality/V8/Crypto/Crypto.cs +++ b/tests/src/JIT/Performance/CodeQuality/V8/Crypto/Crypto.cs @@ -46,7 +46,7 @@ using System.Globalization; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] -namespace Crypto +namespace V8.Crypto { public class Support { diff --git a/tests/src/JIT/Performance/CodeQuality/V8/DeltaBlue/DeltaBlue.cs b/tests/src/JIT/Performance/CodeQuality/V8/DeltaBlue/DeltaBlue.cs index ee14b8b1b1..27f77182b2 100644 --- a/tests/src/JIT/Performance/CodeQuality/V8/DeltaBlue/DeltaBlue.cs +++ b/tests/src/JIT/Performance/CodeQuality/V8/DeltaBlue/DeltaBlue.cs @@ -24,13 +24,15 @@ using System.Collections; [assembly: OptimizeForBenchmarks] [assembly: MeasureInstructionsRetired] -/* +/* Strengths are used to measure the relative importance of constraints. New strengths may be inserted in the strength hierarchy without disrupting current constraints. Strengths cannot be created outside this class, so pointer comparison can be used for value comparison. */ +namespace V8 +{ internal class Strength { private int _strengthValue; @@ -1066,3 +1068,4 @@ public class deltablue throw new Exception(s); } } +} diff --git a/tests/src/JIT/Performance/CodeQuality/V8/Richards/Richards.cs b/tests/src/JIT/Performance/CodeQuality/V8/Richards/Richards.cs index 6d26593e2f..5095d22ad7 100644 --- a/tests/src/JIT/Performance/CodeQuality/V8/Richards/Richards.cs +++ b/tests/src/JIT/Performance/CodeQuality/V8/Richards/Richards.cs @@ -20,7 +20,7 @@ using System.Collections.Generic; // using System.Diagnostics; // using System.Text.RegularExpressions; -namespace Richards +namespace V8.Richards { /// <summary> /// Support is used for a place to generate any 'miscellaneous' methods generated as part @@ -501,7 +501,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif TaskControlBlock run(Packet packet) { @@ -521,7 +521,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif String toString() { @@ -548,7 +548,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif TaskControlBlock run(Packet packet) { @@ -568,7 +568,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif String toString() { @@ -598,7 +598,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif TaskControlBlock run(Packet packet) { @@ -630,7 +630,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif String toString() { @@ -658,7 +658,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif TaskControlBlock run(Packet packet) { @@ -700,7 +700,7 @@ namespace Richards public #if !INTF_FOR_TASK - override + override #endif String toString() { diff --git a/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cmd b/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cmd index e85e226392..e7b8917757 100644 --- a/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cmd +++ b/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.cmd @@ -9,7 +9,7 @@ @rem of the enlistment(repo). It also requires that CoreCLR has been built, @rem and that all CoreCLR tests have been built. @rem -@rem The preformance harness "RunBencchmarks.exe" is built as a test case +@rem The preformance harness "RunBenchmarks.exe" is built as a test case @rem as are all the performance tests it runs. @rem @rem For the ByteMark tests, it must copy the command scripts to the diff --git a/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.sh b/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.sh new file mode 100755 index 0000000000..ee709164c9 --- /dev/null +++ b/tests/src/JIT/Performance/RunBenchmarks/RunBenchmarks.sh @@ -0,0 +1,53 @@ +# *************************************************************************** +# RunBenchmarks.sh +# +# This is a sample script for how to run benchmarks on Unix-like system. +# +# It requires the user to set CORECLR_ROOT to the root directory +# of the enlistment(repo). It also requires that CoreCLR has been built, +# and that all CoreCLR tests have been built. +# +# The preformance harness "RunBenchmarks.exe" is built as a test case +# as are all the performance tests it runs. +# +# For the ByteMark tests, it must copy the command scripts to the +# binary directory for the tests. +# +# By default, the performance harness is run on top of CoreCLR. There +# is a commented out section that can be used to run on top of DesktopCLR. +# +# A standard benchmark run is done with one warmup run, and five iterations +# of the benchmark. +# +# *************************************************************************** + +ARCH=${1:-x64} +BUILD=${2:-Release} + +CORERUN=${CORERUN:-corerun} + +# *** set this appropriately for enlistment you are running benchmarks in + +if [ -z "$CORECLR_ROOT" ]; then + echo "You must set CORECLR_ROOT to be the root of your coreclr repo (e.g. /git/repos/coreclr)" + exit 1 +fi + +# *** Currently we can build test cases only on Windows, so "Windows_NT" is hard-coded in the variables. +BENCHMARK_ROOT_DIR="$CORECLR_ROOT/bin/tests/Windows_NT.$ARCH.$BUILD/JIT/Performance/CodeQuality" +BENCHMARK_SRC_DIR="$CORECLR_ROOT/tests/src/JIT/Performance/RunBenchmarks" +BENCHMARK_HOST="$CORERUN $CORECLR_ROOT/bin/tests/Windows_NT.$ARCH.$BUILD/JIT/Performance/RunBenchmarks/RunBenchmarks/RunBenchmarks.exe" +BENCHMARK_RUNNER="-runner $CORERUN" + +# *** need to copy command files for Bytemark +mkdir -p ${BENCHMARK_ROOT_DIR}/Bytemark/Bytemark +cp -rf $CORECLR_ROOT/tests/src/JIT/Performance/CodeQuality/Bytemark/commands ${BENCHMARK_ROOT_DIR}/Bytemark/Bytemark/commands + +BENCHMARK_CONTROLS="-run -v -w -n 5" +BENCHMARK_SET="-f $BENCHMARK_SRC_DIR/coreclr_benchmarks.xml -notags broken" +BENCHMARK_OUTPUT="-csvfile $BENCHMARK_SRC_DIR/coreclr_benchmarks.csv" +BENCHMARK_SWITCHES="$BENCHMARK_CONTROLS -r $BENCHMARK_ROOT_DIR" + +echo "$BENCHMARK_HOST $BENCHMARK_RUNNER $BENCHMARK_SET $BENCHMARK_OUTPUT $BENCHMARK_SWITCHES" +$BENCHMARK_HOST $BENCHMARK_RUNNER $BENCHMARK_SET $BENCHMARK_OUTPUT $BENCHMARK_SWITCHES + diff --git a/tests/src/JIT/Regression/CLR-x86-JIT/V2.0-RTM/b475589/b475589.il b/tests/src/JIT/Regression/CLR-x86-JIT/V2.0-RTM/b475589/b475589.il deleted file mode 100644 index dce3d692f8..0000000000 --- a/tests/src/JIT/Regression/CLR-x86-JIT/V2.0-RTM/b475589/b475589.il +++ /dev/null @@ -1,71 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for more information. - -.assembly extern System.Console -{ - .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) - .ver 4:0:0:0 -} - -.assembly extern mscorlib { auto } -.assembly b475598 {} -.module b475589.exe - -.class Program -{ - .method static void Nasty() - { - .maxstack 2 - - call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::PrepareConstrainedRegions() - br start_try - - start_catch: - ldstr "Cathed!" - call void [System.Console]System.Console::WriteLine(string) - leave.s end - end_catch: - - start_try: - newobj instance void [mscorlib]System.Exception::.ctor() - throw - end_try: - - end: - ret - - .try start_try to end_try catch [mscorlib]System.Exception handler start_catch to end_catch - } - .method static int32 Main(string[] args) - { - .maxstack 2 - .entrypoint - - - start_try: - - call void Program::Nasty() - leave.s end_failure - - end_try: - start_catch: - - leave.s end_success - end_catch: - - end_success: - ldstr "Test SUCCESS" - call void [System.Console]System.Console::WriteLine(string) - ldc.i4 100 - ret - - end_failure: - ldstr "Test FAILURE" - call void [System.Console]System.Console::WriteLine(string) - ldc.i4 -1 - ret - - .try start_try to end_try catch [mscorlib]System.NotSupportedException handler start_catch to end_catch - } -}
\ No newline at end of file diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_142976/DevDiv_142976.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_142976/DevDiv_142976.cs new file mode 100644 index 0000000000..7b0151793b --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_142976/DevDiv_142976.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + + +using System; +using System.Runtime.CompilerServices; + +// This test case is meant to test an optimization in morph that +// transforms helper call JIT_Stelem_Ref(a, null, i) to a[i] = null, +// which further gets transformed into an array address and bounds +// check nodes with references to the array local and the index +// local. It is expected while doing such a transform, array +// local and index local are appropriately ref counted and Value +// number is updated post-global-morph and jit compilation +// won't run into any asserts. +class DevDiv_142976 +{ + [MethodImpl(MethodImplOptions.NoInlining)] + public static String Foo() + { + return null; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static void Bar() + { + String[] args = new String[10]; + if (args != null) + { + throw new Exception(); + } + + String s = Foo(); + if (s == null) + { + // This will result in JIT_Stelem_Ref(args, null, 0) call + // which gets re-morphed into args[0] = null. + args[0] = s; + } + } + + public static int Main() + { + try + { + Bar(); + } + catch (Exception) + { + } + + Console.WriteLine("Pass"); + return 100; + } +}
\ No newline at end of file diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_142976/DevDiv_142976.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_142976/DevDiv_142976.csproj new file mode 100644 index 0000000000..0c1a10eb95 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_142976/DevDiv_142976.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_142976.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_255294/DevDiv_255294.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_255294/DevDiv_255294.cs new file mode 100644 index 0000000000..05f1d90aac --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_255294/DevDiv_255294.cs @@ -0,0 +1,62374 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.CompilerServices; + +public class Test +{ + static bool f; + + public static int Main() + { + f = true; + Test test = new Test(); + return test.HugeMethod(); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int HugeMethod() + { + int i = 0; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + if (f) i++; + + return i - 62248; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_255294/DevDiv_255294.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_255294/DevDiv_255294.csproj new file mode 100644 index 0000000000..9027bb5c54 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_255294/DevDiv_255294.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_255294.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278365/DevDiv_278365.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_278365/DevDiv_278365.cs new file mode 100644 index 0000000000..631175a38e --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278365/DevDiv_278365.cs @@ -0,0 +1,49 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + + +using System; +using System.Runtime.CompilerServices; + +// This test is a reduced repro case for DevDiv VSO bug 278365. +// The failure mode is that the RyuJIT/x86 backend changed call to ROUND intrinsic +// with double return type to ROUND intrinsic with int return type, that is not supported. + +internal class Program +{ + [MethodImpl(MethodImplOptions.NoInlining)] + public static int Bar() + { + int sum = 0; + for (int i = 0; i < 100; ++i) + { + int v = (int)Math.Round(4.4 + i); + sum += v; + } + sum -= 4 * 100; + if (sum != 100 * 99 / 2) + { + return 0; + } + else + { + return 100; + } + } + + private static int Main(string[] args) + { + try + { + if (Bar() != 100) + return 0; + } + catch (Exception) + { + } + + Console.WriteLine("Pass"); + return 100; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278365/DevDiv_278365.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278365/DevDiv_278365.csproj new file mode 100644 index 0000000000..0abcfd8a28 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278365/DevDiv_278365.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_278365.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278369/DevDiv_278369.il b/tests/src/JIT/Regression/JitBlue/DevDiv_278369/DevDiv_278369.il new file mode 100644 index 0000000000..cf077786d9 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278369/DevDiv_278369.il @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// This test checks that value numbering does not incorrectly propagate the value number for an operand to its +// consuming operator unless the type of the operand and the operator agree. +// +// In particular, in the body of method N, the optimizer will fold the two `ceq` conditions together using a logical +// or of type int32. Value numbering will then determine that one operand to the logical or is a constant `0` (namely, +// the result of `ldloc.0` and attempt to propagate the value number of the logical or's other operand to the logical +// or itself. This should not succeed, as the type of the logical or is int32 and the type of its non-zero operand is +// `ref`. + +.assembly extern mscorlib {} + +.assembly r {} + +.class private auto ansi beforefieldinit C extends [mscorlib]System.Object +{ + .method private hidebysig static int32 N(object o) cil managed noinlining + { + .locals (int32) + + ldc.i4.0 + stloc.0 + ldarg.0 + isinst C + ldnull + ceq + brfalse.s label + ldloc.0 + ldc.i4.0 + ceq + brfalse.s label + ldc.i4.s 0 + ret + +label: + ldc.i4 100 + ret + } + + .method private hidebysig static int32 Main(string[] args) cil managed + { + .entrypoint + + newobj instance void C::.ctor() + call int32 C::N(object) + ret + } + + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed + { + ldarg.0 + call instance void [mscorlib]System.Object::.ctor() + ret + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278369/DevDiv_278369.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278369/DevDiv_278369.ilproj new file mode 100644 index 0000000000..deebeec0d1 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278369/DevDiv_278369.ilproj @@ -0,0 +1,41 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_278369.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278371/DevDiv_278371.il b/tests/src/JIT/Regression/JitBlue/DevDiv_278371/DevDiv_278371.il new file mode 100644 index 0000000000..447392e1fd --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278371/DevDiv_278371.il @@ -0,0 +1,88 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// Test for a bug involving an initblk with a non-constant size, +// which uses rep movs on x86 (x64 uses a helper call). + +.assembly extern legacy library mscorlib {} +.assembly extern System.Console +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) + .ver 4:0:0:0 +} + +.assembly DevDiv_278371 {} + +.class public sequential ansi sealed beforefieldinit S + extends [mscorlib]System.ValueType +{ + .field public uint32 val +} // end of class S + +.class private auto ansi beforefieldinit Program + extends [mscorlib]System.Object +{ + .method public hidebysig static void Init(valuetype S& s, + int32 size) cil managed noinlining + { + nop + ldarg.0 + ldc.i4 0xaa + ldarg.1 + initblk + ret + } // end of method Program::Init + + .method private hidebysig static int32 + Main() cil managed + { + .entrypoint + .locals init (valuetype S V_0, + bool V_1, + int32 V_2) + ldloca.s V_0 + initobj S + ldloca.s V_0 + ldc.i4 4 + call void Program::Init(valuetype S&, int32) + ldloc.0 + ldfld uint32 S::val + ldc.i4 0xaaaaaaaa + ceq + ldc.i4.0 + ceq + stloc.1 + ldloc.1 + brfalse.s L1 + + ldstr "Fail" + call void [mscorlib]System.Console::WriteLine(string) + nop + ldc.i4.m1 + stloc.2 + br.s L2 + + L1: ldstr "Pass" + call void [mscorlib]System.Console::WriteLine(string) + nop + ldc.i4.s 100 + stloc.2 + + L2: ldloc.2 + ret + } // end of method Program::Main + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 8 (0x8) + .maxstack 8 + ldarg.0 + call instance void [mscorlib]System.Object::.ctor() + nop + ret + } // end of method Program::.ctor + +} // end of class Program + diff --git a/tests/src/JIT/Regression/CLR-x86-JIT/V2.0-RTM/b475589/b475589.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278371/DevDiv_278371.ilproj index 14ed64f690..11cfb62342 100644 --- a/tests/src/JIT/Regression/CLR-x86-JIT/V2.0-RTM/b475589/b475589.ilproj +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278371/DevDiv_278371.ilproj @@ -26,10 +26,11 @@ </CodeAnalysisDependentAssemblyPaths> </ItemGroup> <PropertyGroup> - + <DebugType>None</DebugType> + <Optimize>True</Optimize> </PropertyGroup> <ItemGroup> - <Compile Include="b475589.il" /> + <Compile Include="DevDiv_278371.il" /> </ItemGroup> <ItemGroup> <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> @@ -37,4 +38,4 @@ <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> </PropertyGroup> -</Project>
\ No newline at end of file +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278372/DevDiv_278372.il b/tests/src/JIT/Regression/JitBlue/DevDiv_278372/DevDiv_278372.il new file mode 100644 index 0000000000..1081877171 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278372/DevDiv_278372.il @@ -0,0 +1,156 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// This test is a reduced repro case for DevDiv VSO bug 278372. +// The failure mode is that the RyuJIT/x86 backend was not correctly +// handling the case of a variable involving a variable V such that: +// - V is lvMustInit (therefore it must be undefined on some path) +// - V lives in multiple registers, but never on the stack +// - there is at least one other variable that is also lvMustInit, but that +// has a stack location. +// +// In this case, genFnProlog was attempting to zero-init V on the stack. +// +// It was difficult to construct a repro; this repro requires that the test +// be run with COMPlus_JitStressRegs=0x200 (which changes the location of +// variables at block boundaries). + + +// Metadata version: v4.0.30319 +.assembly extern System.Runtime +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) // .?_....: + .ver 4:1:0:0 +} +.assembly extern System.Console +{ + .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) // .?_....: + .ver 4:0:0:0 +} +.assembly DevDiv_278372 +{ +} + +// =============== CLASS MEMBERS DECLARATION =================== + +.class private auto ansi beforefieldinit DevDiv_278372 + extends [System.Runtime]System.Object +{ + .method public hidebysig static bool check(int32& dummy) cil managed noinlining + { + ldc.i4.1 + ret + } // end of method DevDiv_278372::check + + .method public hidebysig static int32 getX() cil managed noinlining + { + ldc.i4.s 25 + ret + } // end of method DevDiv_278372::getX + + .method public hidebysig static int32 getY() cil managed noinlining + { + ldc.i4.5 + ret + } // end of method DevDiv_278372::getY + + .method public hidebysig static int32 Test(int32 x, + int32 y, + int32 x2, + int32 y2, + int32 x3, + int32 y3) cil managed noinlining + { + .maxstack 2 + .locals init ([0] int32 z, + [1] int32 returnVal, + [2] int32 dummy, + [3] int32 z2) + + // Initialize returnVal to 100 + ldc.i4.s 100 + stloc.1 + + // Here we pass the address of "dummy" to ensure that we have a must-init on-stack variable. + ldloca.s dummy + call bool DevDiv_278372::check(int32&) + brfalse.s L1 + + // Here we are conditionally defining "z", so that it will be must-init + ldarg.0 + ldarg.1 + rem + stloc.0 + L1: ldloc.0 + brfalse.s L2 + + ldc.i4.m1 + stloc.1 + L2: ldarg.2 + ldarg.3 + rem + stloc.3 + ldarg.0 + ldarg.1 + add + stloc.0 + ldloc.0 + ldc.i4.s 30 + beq.s L3 + + ldc.i4.m1 + stloc.1 + L3: ldloc.3 + brfalse.s L4 + + ldc.i4.m1 + stloc.1 + L4: ldloc.1 + ldc.i4.s 100 + bne.un.s L5 + + ldstr "Pass" + call void [System.Console]System.Console::WriteLine(string) + br.s L6 + + L5: ldstr "Fail" + call void [System.Console]System.Console::WriteLine(string) + L6: ldloc.1 + ret + } // end of method DevDiv_278372::Test + + .method public hidebysig static int32 Main() cil managed + { + .entrypoint + // Code size 16 (0x10) + .maxstack 8 + ldc.i4.s 25 + ldc.i4.5 + ldc.i4.s 25 + ldc.i4.5 + ldc.i4.s 25 + ldc.i4.5 + call int32 DevDiv_278372::Test(int32, + int32, + int32, + int32, + int32, + int32) + ret + } // end of method DevDiv_278372::Main + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + ldarg.0 + call instance void [System.Runtime]System.Object::.ctor() + ret + } // end of method DevDiv_278372::.ctor + +} // end of class DevDiv_278372 + + +// ============================================================= diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278372/DevDiv_278372.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278372/DevDiv_278372.ilproj new file mode 100644 index 0000000000..f3da12d5f0 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278372/DevDiv_278372.ilproj @@ -0,0 +1,51 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_278372.il" /> + </ItemGroup> + <PropertyGroup> + <CLRTestBatchPreCommands><![CDATA[ +$(CLRTestBatchPreCommands) +set COMPlus_JitStressRegs=0x200 +]]></CLRTestBatchPreCommands> + <BashCLRTestPreCommands><![CDATA[ +$(BashCLRTestPreCommands) +export COMPlus_JitStressRegs=0x200 +]]></BashCLRTestPreCommands> + </PropertyGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278375/DevDiv_278375.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_278375/DevDiv_278375.cs new file mode 100644 index 0000000000..ecd7e7fa38 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278375/DevDiv_278375.cs @@ -0,0 +1,131 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +using System; +using System.Runtime.CompilerServices; + +struct MyStruct +{ + // Struct containing 4 fields, 3 of which are longs that will be decomposed. + // The bug was that this resulted in 7 input registers to the GT_FIELD_LIST + // parameter, which can't be accommodated by the register allocator. + + public MyStruct(long l1, long l2, long l3, int i) + { + f1 = l1; + f2 = l2; + f3 = l3; + f4 = new int[i]; + f4[0] = i; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static MyStruct newMyStruct(long l1, long l2, long l3, int i) + { + return new MyStruct(l1, l2, l3, i); + } + + public long f1; + public long f2; + public long f3; + public int[] f4; +} + +struct MyStruct2 +{ + // This is a variation that includes a double field, to ensure that a mix of + // field types are supported. + public MyStruct2(long l1, long l2, double d, int i) + { + f1 = l1; + f2 = l2; + f3 = d; + f4 = new int[i]; + f4[0] = i; + } + + public long f1; + public long f2; + public double f3; + public int[] f4; +} + +struct MyStruct3 +{ + // And finally one that includes longs and a double, but no ref. + public MyStruct3(long l1, long l2, double d, int i) + { + f1 = l1; + f2 = l2; + f3 = d; + f4 = i; + } + + public long f1; + public long f2; + public double f3; + public int f4; +} + +class Program +{ + + static int Pass = 100; + static int Fail = -1; + + [MethodImpl(MethodImplOptions.NoInlining)] + static int AddFields(MyStruct s) + { + return (int)(s.f1 + s.f2 + s.f3 + s.f4[0]); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int AddFields2(MyStruct2 s) + { + return (int)(s.f1 + s.f2 + (int)s.f3 + s.f4[0]); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int AddFields3(MyStruct3 s) + { + return (int)(s.f1 + s.f2 + (int)s.f3 + s.f4); + } + + static int Main(string[] args) + { + int returnVal = Pass; + MyStruct s = new MyStruct(1, 2, 3, 4); + int sum = AddFields(s); + if (sum != 10) + { + Console.WriteLine("Failed first call"); + returnVal = Fail; + } + s = MyStruct.newMyStruct(1, 2, 3, 4); + sum = AddFields(s); + if (sum != 10) + { + Console.WriteLine("Failed second call"); + returnVal = Fail; + } + MyStruct2 s2 = new MyStruct2(1, 2, 3.0, 4); + sum = AddFields2(s2); + if (sum != 10) + { + Console.WriteLine("Failed third call"); + returnVal = Fail; + } + MyStruct3 s3 = new MyStruct3(1, 2, 3.0, 4); + sum = AddFields3(s3); + if (sum != 10) + { + Console.WriteLine("Failed fourth call"); + returnVal = Fail; + } + if (returnVal == Pass) + { + Console.WriteLine("Pass"); + } + return returnVal; + } +}
\ No newline at end of file diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278375/DevDiv_278375.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278375/DevDiv_278375.csproj new file mode 100644 index 0000000000..9477984ab9 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278375/DevDiv_278375.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_278375.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278376/DevDiv_278376.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_278376/DevDiv_278376.cs new file mode 100644 index 0000000000..63e3d29f7a --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278376/DevDiv_278376.cs @@ -0,0 +1,36 @@ +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// NOTE: the bug for this test was an assertion in RyuJIT/x86 when generating code for a double-returning call that +// was spilled by the RA and subsequently used. The call in question is the call to `C.GetDouble` in `C.Test`. +// To ensure that its return value is spilled, `C.GetDouble` is implemented as a P/Invoke method: the return +// value ends up spilled because there is a call to `TrapReturningThreads` between the call and the use of the +// return value by the cast. Because the bug is a simple assert, there is no need for the problematic code to +// actually run, so the implementation of `GetDouble` does not need to actually exist. + +sealed class C +{ + [DllImport("nonexistent.dll")] + extern static double GetDouble(); + + [MethodImpl(MethodImplOptions.NoInlining)] + static void UseDouble(double d) + { + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int Test(bool condition) + { + if (condition) + { + UseDouble((double)GetDouble()); + } + + return 100; + } + + static int Main(string[] args) + { + return Test(false); + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278376/DevDiv_278376.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278376/DevDiv_278376.csproj new file mode 100644 index 0000000000..90327b2a5d --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278376/DevDiv_278376.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_278376.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278523/DevDiv_278523.il b/tests/src/JIT/Regression/JitBlue/DevDiv_278523/DevDiv_278523.il new file mode 100644 index 0000000000..9c9ba4946c --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278523/DevDiv_278523.il @@ -0,0 +1,113 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +.assembly extern mscorlib {} +.assembly a {} +.module a.exe + +// This test originally triggered an assert when computing the value number for a block assignment. In particular, the +// VN framework expected any block assignments to a tracked lclVar to have a destination address of the form +// `(addr (lclVar))` or `(addr (lclFld))`. The check that it was using to determine whether or not a block assignment +// targets a lclVar also admitted addresses formed by some combination of adds of constants to these patterns (e.g. +// `(add (const 4) (add (addr lclVar) (const 4)))`. The bits of IL that trigger the assert are called out in the method +// bodies below. They differ for 32- and 64-bit targets because on 64-bit targets, the importer will insert an +// int->long conversion when adding a constant int to any long. Due to the cast, the resulting IR is not considered to +// be an add of a constant and a lclVar address. In order to repro the bug on a 64-bit target, the input IL must +// directly produce a long constant. + +.class private sequential ansi sealed beforefieldinit S extends [mscorlib]System.ValueType +{ + .field public uint8 m_fld + .field public uint8 m_fld1 + .field public uint8 m_fld2 + .field public uint8 m_fld3 + .field public uint8 m_fld4 + .field public uint8 m_fld5 + .field public uint8 m_fld6 +} + +.class private sequential ansi sealed beforefieldinit T extends [mscorlib]System.ValueType +{ + .field public int32 m_int + .field public valuetype S m_fld +} + +.class private abstract auto ansi sealed beforefieldinit C extends [mscorlib]System.Object +{ + .method private static int32 Test32Bit(int32 i) noinlining + { + .locals init (valuetype S V_0, valuetype T V_1) + + ldloca.s V_0 + ldarg.0 + conv.u1 + stfld uint8 S::m_fld6 + + // This sequence of IL repros the issue. + ldloca.s V_1 + ldc.i4.4 + add + ldloc.0 + stobj S + + ldloca.s V_1 + ldfld valuetype S T::m_fld + ldfld uint8 S::m_fld6 + conv.i4 + ret + } + + .method private static int32 Test64Bit(int32 i) noinlining + { + .locals init (valuetype S V_0, valuetype T V_1) + + ldloca.s V_0 + ldarg.0 + conv.u1 + stfld uint8 S::m_fld6 + + // This sequence of IL repros the issue. Note that the `ldc.i8` is necessary (rather than an `ldc.i4` that is + // implicitly converted to a long byt the `add`). + ldloca.s V_1 + ldc.i8 4 + add + ldloc.0 + stobj S + + ldloca.s V_1 + ldfld valuetype S T::m_fld + ldfld uint8 S::m_fld6 + conv.i4 + ret + } + + .method private static int32 Main() + { + .entrypoint + .locals init (int32 V_0) + + ldc.i4 100 + dup + + sizeof [mscorlib]System.IntPtr + ldc.i4 8 + beq.s _64bit + + call int32 C::Test32Bit(int32) + bne.un.s fail + br.s success + +_64bit: + call int32 C::Test64Bit(int32) + bne.un.s fail + +success: + ldc.i4 100 + ret + +fail: + ldc.i4 101 + ret + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278523/DevDiv_278523.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278523/DevDiv_278523.ilproj new file mode 100644 index 0000000000..d4cfe45c95 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278523/DevDiv_278523.ilproj @@ -0,0 +1,41 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_278523.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278526/DevDiv_278526.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_278526/DevDiv_278526.cs new file mode 100644 index 0000000000..e3c494b66d --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278526/DevDiv_278526.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// This test was originally a repro for an assertion regarding incorrect value number of the tree in cse. +// The repro requires that the tree and its child are considered by cse and child is binary sub (a - b). +// Cse calls morph of the parent tree and morphs child to (a + (-b)) and sets the clean VN state to the child. +// It causes assert when cse processes the child with the clean vn state. + + +using System; + + +class Program +{ + public sealed class Variables + { + public static byte[] decryptedApplicationData + { + get; + set; + } + } + + private static bool VerifyMacvalueSSlV2(string sourceIP) + { + if (sourceIP == "skip") + return false; + + byte[] array3 = new byte[0]; + + // Assert happens on the next two statements. + int l = Variables.decryptedApplicationData.Length - array3.Length - 16; + byte[] array2 = new byte[l]; + + if (array3[0] != array2[0]) + return false; + return true; + } + + public static int Main(string[] args) + { + string s = "skip"; // Test checks commpilation process. + VerifyMacvalueSSlV2(s); + return 100; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_278526/DevDiv_278526.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_278526/DevDiv_278526.csproj new file mode 100644 index 0000000000..b1bd003732 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_278526/DevDiv_278526.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_278526.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_279396/DevDiv_279396.il b/tests/src/JIT/Regression/JitBlue/DevDiv_279396/DevDiv_279396.il new file mode 100644 index 0000000000..70e02027fc --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_279396/DevDiv_279396.il @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +.assembly extern mscorlib {} +.assembly DevDiv_279396 {} +.module DevDiv_279396.exe + +// This test originally triggered an assertion in the emitter that ensured that no lclVar or lclFld access exceeded the +// bounds of its containing method's frame. The problematic access was created during morphing by folding +// `(ind long (addr int (lclVar int V0)))` into `(lclFld long V0 0)`. This corresponds to the body of `C::Test` below. + +.class private abstract auto ansi sealed beforefieldinit C extends [mscorlib]System.Object +{ + .method private static int64 Test(int32 i) noinlining + { + ldarga.s i + ldind.i8 + ret + } + + .method private static int32 Main() + { + .entrypoint + + ldc.i4 100 + dup + call int64 C::Test(int32) + conv.i4 + bne.un.s fail + + ldc.i4 100 + ret + +fail: + ldc.i4 101 + ret + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_279396/DevDiv_279396.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_279396/DevDiv_279396.ilproj new file mode 100644 index 0000000000..2a9f58bf7d --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_279396/DevDiv_279396.ilproj @@ -0,0 +1,41 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_279396.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_279829/DevDiv_279829.il b/tests/src/JIT/Regression/JitBlue/DevDiv_279829/DevDiv_279829.il new file mode 100644 index 0000000000..96c22d24d6 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_279829/DevDiv_279829.il @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +.assembly extern mscorlib {} + +.assembly DevDiv_279829.exe {} + +.class public Test +{ + .method private static int32 JmpTarget(int64) + { + .maxstack 1 + ldarg.0 + conv.i4 + ret + } + + .method private static int32 Jmp(int64) + { + .maxstack 1 + jmp int32 Test::JmpTarget(int64) + ldc.i4 0 + ret + } + + .method private static int32 Main(class [mscorlib]System.String[]) + { + .entrypoint + .maxstack 1 + + ldc.i8 100 + call int32 Test::Jmp(int64) + ret + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_279829/DevDiv_279829.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_279829/DevDiv_279829.ilproj new file mode 100644 index 0000000000..d4804c8cdc --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_279829/DevDiv_279829.ilproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <RestorePackages>true</RestorePackages> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <Optimize>true</Optimize> + <DebugType>None</DebugType> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_279829.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_280120/DevDiv_280120.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_280120/DevDiv_280120.cs new file mode 100644 index 0000000000..39888b100d --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_280120/DevDiv_280120.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// This test was originally a repro for an assertion regarding incorrect lclVar ref counts due to a bug in the +// decomposition of a long-typed st.lclFld node. The repro requires that a dead store of this type survives until +// decomposition. We must therefore avoid running liveness before decomposition as part of this test, which requires +// skipping SSA (and dependent optimizations). This pass is disabled in the project file by setting JitDoSsa to 0 +// before running the test. + +struct S +{ + long m_fld; + int m_a, m_b, m_c, m_d; + + static int Main(string[] args) + { + S s; + s.m_fld = (long)args.Length; + return 100; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_280120/DevDiv_280120.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_280120/DevDiv_280120.csproj new file mode 100644 index 0000000000..bcbdc0f452 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_280120/DevDiv_280120.csproj @@ -0,0 +1,56 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_280120.cs" /> + </ItemGroup> + <PropertyGroup> + <CLRTestBatchPreCommands><![CDATA[ +$(CLRTestBatchPreCommands) +set COMPlus_JitDoSsa=0 +]]></CLRTestBatchPreCommands> + <BashCLRTestPreCommands><![CDATA[ +$(BashCLRTestPreCommands) +export COMPlus_JitDoSsa=0 +]]></BashCLRTestPreCommands> + </PropertyGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_280123/DevDiv_280123.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_280123/DevDiv_280123.cs new file mode 100644 index 0000000000..01e55ed580 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_280123/DevDiv_280123.cs @@ -0,0 +1,42 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Runtime.CompilerServices; + +// This test ensures that the value number store (and its users) behave properly in the event that VN data is requested +// for trees without value numbers. The original repro was a rather large method with a significant amount of dead code +// due to the pattern exhibited in C.N: an entry block that was not transformed from a conditional return to an +// unconditional return followed by dead code that must be kept due to the presence of EH. Value numbering does not +// assign value numbers to the dead code, but assertion prop still runs over the dead code and attempts to use VN info, +// which resulted in a number of asserts. + +static class C +{ + [MethodImpl(MethodImplOptions.NoInlining)] + static int N(ref int i) + { + bool b = true; + if (b) + { + return 100; + } + + try + { + b = i != 1; + } + finally + { + b = i != 0; + } + + return b ? 0 : 1; + } + + static int Main(string[] args) + { + int i = args.Length; + return N(ref i); + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_280123/DevDiv_280123.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_280123/DevDiv_280123.csproj new file mode 100644 index 0000000000..a2ec9758cc --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_280123/DevDiv_280123.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_280123.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_280127/DevDiv_280127.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_280127/DevDiv_280127.cs new file mode 100644 index 0000000000..3f8270f70c --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_280127/DevDiv_280127.cs @@ -0,0 +1,37 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.CompilerServices; + +// The original repro for this test was an assertion after code generation that the actual maximum depth of the stack +// was less than or identical to the estimated depth of the stack as calculated during morph. The calculation was +// incorrect when a math intrinsic was used as an argument to a function with on-stack parameters (e.g. the call to +// `M` on line 18). + +static class C +{ + struct S + { + int a, b, c, d; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int N(S s, float d) + { + return 100; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int M(double d) + { + N(new S(), (float)(Math.Atan2(d, 2.0) * 180 / Math.PI)); + return 100; + } + + static int Main() + { + return M(2.0); + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_280127/DevDiv_280127.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_280127/DevDiv_280127.csproj new file mode 100644 index 0000000000..ec9776df87 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_280127/DevDiv_280127.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_280127.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_283795/DevDiv_283795.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_283795/DevDiv_283795.cs new file mode 100644 index 0000000000..55da5ba1e9 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_283795/DevDiv_283795.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Runtime.CompilerServices; + +class C +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + static int[] M() + { + return null; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool Test(int i, int j, bool execute) + { + if (execute) + { + return M()[checked(i + j)] == 0; + } + + return true; + } + + static int Main() + { + // The original repro of the bug associated with this test involved an assert after re-morphing a tree modified + // by CSE: the original tree contained both a CSE def and a CSE use, and re-morphing eliminated the use, causing + // CSE to assert when attempting to replace the use with a reference to the CSE lclVar. This call to `Test` is + // intended to trigger that assert. + bool test1 = Test(0, 0, false); + + // The associated code in morph involves folding `(x + null)` to `x`. During the investigation of the original + // issue, it was found that the folding code also failed to check for side effects in `x` resulting in SBCG if + // side effects were in fact present in `x`. This call to `Test` is intended to ensure that the fold is not + // performed in the face of a tree that contains side-effects: in particular, the overflowing add in the + // called method should occur before any other exception. + bool test2 = false; + try + { + Test(int.MaxValue, int.MaxValue, true); + } + catch (System.OverflowException) + { + test2 = true; + } + catch (System.Exception e) + { + System.Console.WriteLine(e); + } + + return test1 && test2 ? 100 : 101; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_283795/DevDiv_283795.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_283795/DevDiv_283795.csproj new file mode 100644 index 0000000000..71bd55fbf9 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_283795/DevDiv_283795.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_283795.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_284785/DevDiv_284785.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_284785/DevDiv_284785.cs new file mode 100644 index 0000000000..944993f038 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_284785/DevDiv_284785.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// This test exercises expression folding in the place of overflowing operations. The original failure was SBCG due to +// an incorrect application of the same: in the program below, the checked int -> ulong cast on line 24 was folded to a +// long -> ulong cast with an incorrect constant value that fit in a ulong, resulting in no overflow exception being +// thrown. + +using System; + +static class C +{ + static int Main() + { + int i = -4; + ulong l = 0; + + int rv = 0; + try + { + checked + { + l = (ulong)i; + } + } + catch (OverflowException) + { + rv = 100; + } + catch (Exception) + { + i = 0; + l = 0; + } + + return rv; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_284785/DevDiv_284785.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_284785/DevDiv_284785.csproj new file mode 100644 index 0000000000..d27b911ee9 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_284785/DevDiv_284785.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_284785.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_288222/DevDiv_288222.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_288222/DevDiv_288222.cs new file mode 100644 index 0000000000..e24c7977ba --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_288222/DevDiv_288222.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + + +using System; +using System.Runtime.CompilerServices; +using System.Numerics; + +// This test is a repro case for DevDiv VSO bug 288222. +// The failure mode is that the size was not being set for a "this" pointer +// with SIMD type. + +internal class Program +{ + // Declare a delegate type for calling the Vector2.CopyTo method. + public delegate void CopyToDelegate(float[] array, int start); + + [MethodImpl(MethodImplOptions.NoInlining)] + public static void MyCopyTo(CopyToDelegate doCopy, float[] array, int start) + { + doCopy(array, start); + } + + private static int Main(string[] args) + { + try + { + float x = 1.0F; + float y = 2.0F; + Vector2 v = new Vector2(x, y); + float[] array = new float[4]; + MyCopyTo(new CopyToDelegate(v.CopyTo), array, 2); + + if ((array[2] != x) || (array[3] != y)) + { + Console.WriteLine("Failed with wrong values"); + return -1; + } + } + catch (Exception e) + { + Console.WriteLine("Failed with exception: " + e.Message); + return -1; + } + + Console.WriteLine("Pass"); + return 100; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_288222/DevDiv_288222.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_288222/DevDiv_288222.csproj new file mode 100644 index 0000000000..0aa2d11c7b --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_288222/DevDiv_288222.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_288222.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_359734/DevDiv_359734.il b/tests/src/JIT/Regression/JitBlue/DevDiv_359734/DevDiv_359734.il new file mode 100644 index 0000000000..43f55b6e81 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_359734/DevDiv_359734.il @@ -0,0 +1,118 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// The original bug for this test was an assertion after the following sequence of events: +// - Assertion propagation constant propagated away the ldlocs, or, and shl in the IL at label "expr" +// - After constant propagation, the resulting expression--`(mod tmp0 cns)`--was remorphed, which +// replaced the modulus with `(sub tmp0 (mul (div tmp0 cns) cns))` and unset the "exception" flag. +// Critically, this transformation added a new use of `tmp0` without updating the ref count for `tmp0`. +// - After morphing, the resulting expression was both unsused and side-effect-free, and was removed +// - While removing the lclVar ref count for `tmp0` fell to `0` +// - Later, liveness found a reference to `tmp0` despite the `0` lclVar count and asserted. +// +// The fix was to bump lclVar ref counts after remorphing but before attempting to remove the expression. + +.assembly extern mscorlib{} +.assembly ILGEN_MODULE{} +.class ILGEN_CLASS +{ + .method static char ILGEN_METHOD(bool, char, int16, int32) + { + .maxstack 65535 + .locals init (int32, int16, int64, int16, unsigned int8, float32, unsigned int8) + + ldc.i8 0x80BBE1AB + ldc.i8 0x866D9EF3 + or + ldarg 0x1 + shl + ldc.i8 0xC09C2177 + sub.ovf.un + conv.ovf.u8.un + ldc.i8 0x82B1C678 + or + ldc.r8 -0.000000 + ldloc 0x5 + ckfinite + ldloc 0x5 + neg + neg + add + add + ldc.r8 0.000000 + clt + stloc.s 0x4 + ldc.i8 0xACB4FC40 + + expr: + ldloc.s 0x3 + ldloc.s 0x0 + or + shl + rem + + conv.ovf.i8 + ldloc.s 0x4 + conv.ovf.u + neg + brtrue IL_0089 + ldarg 0x0 + conv.ovf.i8 + conv.i8 + ldc.i8 0x2ECADED8 + ldloc 0x2 + shr + clt + pop + ldloc.s 0x1 + conv.ovf.u1.un + conv.ovf.u.un + starg 0x0 + + IL_0089: + ldarg.s 0x3 + conv.u8 + bgt IL_0094 + ldloc.s 0x5 + pop + + IL_0094: + ldc.r8 0.000000 + neg + conv.i + ldloc 0x5 + ckfinite + ldc.i8 0x8BD98F2C + conv.r4 + ckfinite + clt + pop + neg + ret + } + + .method static int32 Main() + { + .entrypoint + + .try + { + ldc.i4 0 + dup + dup + dup + call char ILGEN_CLASS::ILGEN_METHOD(bool, char, int16, int32) + pop + leave.s done + } + catch [mscorlib]System.Exception + { + leave.s done + } + + done: + ldc.i4 100 + ret + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_359734/DevDiv_359734.ilproj b/tests/src/JIT/Regression/JitBlue/DevDiv_359734/DevDiv_359734.ilproj new file mode 100644 index 0000000000..b13550f980 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_359734/DevDiv_359734.ilproj @@ -0,0 +1,41 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_359734.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736.cs b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736.cs new file mode 100644 index 0000000000..56f7b903f3 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736.cs @@ -0,0 +1,42 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. +// + +using System; +using System.Runtime.CompilerServices; + +// This testcase reproduces a bug where the tree re-sequencing was not correct for +// fgMorphModToSubMulDiv(), resulting in an assert in LSRA. + +static class Test +{ + static byte GetVal() + { + return 0; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static int DoMod(SByte arg) + { + byte val = GetVal(); + return arg % val; + } + + static int Main() + { + int returnVal = -1; + try + { + DoMod(4); + Console.WriteLine("FAILED: No exception thrown"); + returnVal = -1; + } + catch (System.DivideByZeroException) + { + Console.WriteLine("PASS"); + returnVal = 100; + } + return returnVal; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_d.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_d.csproj new file mode 100644 index 0000000000..93bc9fd04f --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_d.csproj @@ -0,0 +1,45 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{23E1CE24-CCFB-4163-A861-D48A76295E8F}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>Full</DebugType> + <Optimize>False</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_359736.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_do.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_do.csproj new file mode 100644 index 0000000000..07c2edfb09 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_do.csproj @@ -0,0 +1,45 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{C8DB97C3-1D53-4192-AE65-74A66EFE0841}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>Full</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_359736.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_r.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_r.csproj new file mode 100644 index 0000000000..fcc7a165ca --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_r.csproj @@ -0,0 +1,45 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{C7C7808C-AFDF-4267-B295-C9D0E9EF5642}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>False</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_359736.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_ro.csproj b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_ro.csproj new file mode 100644 index 0000000000..c8a1bef582 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/DevDiv_359736/DevDiv_359736_ro.csproj @@ -0,0 +1,45 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{30EFB3A3-FDAB-43C1-91E5-0496C0B9C689}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="DevDiv_359736.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)threading+thread\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)threading+thread\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_7906/GitHub_7906.cs b/tests/src/JIT/Regression/JitBlue/GitHub_7906/GitHub_7906.cs new file mode 100644 index 0000000000..47f16d7fbf --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_7906/GitHub_7906.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// Regression test for insufficient guard on inference of initial values +// of induction variables. +using System.Numerics; + +namespace N +{ + public static class C + { + public static int Main(string[] args) + { + int x = 0; + + // When bottom-testing sees this loop, it (questionably for performance, + // but correctly) copies only the first part of the disjunctive loop condition + // so we get + // + // B1: i = Count // initialization + // B2: if (i < Count) goto B6 // duplicated loop condition (note the "zero trip" case goes to the 2nd loop condition disjunct) + // B3: x += i // loop body + // B4: ++i // increment + // B5: if (i < Count) goto B3 // first disjunct of loop condition + // B6: if (i < 20) goto B3 // second disjunct of loop condition + // B7: return x - 84 // post-loop + // + // At which point B3..B6 is an irreducible loop, but B3..B5 is a natural loop. + // This is a regression test for a bug where optRecordLoop would incorrectly + // identify B1 as the initial value of loop B3..B5 -- this is incorrect because + // the edge from B6 to B3 enters the loop with different values of i. + // + // The testcase is intentionally structured so that loop unrolling will try + // to unroll loop B3..B5 and generate incorrect code due to the incorrect + // initial value. + for (int i = Vector<int>.Count; i < Vector<int>.Count || i < 20; ++i) + { + x += i; + } + + // After running the loop above, the value of x should be (Count + 19) * (20 - Count) / 2. + // Return 100 + x - (expected x) so the test will return 100 on success. + return 100 + x - ((Vector<int>.Count + 19) * (20 - Vector<int>.Count) / 2); + } + } +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_7906/GitHub_7906.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_7906/GitHub_7906.csproj new file mode 100644 index 0000000000..1dbbc3bb45 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_7906/GitHub_7906.csproj @@ -0,0 +1,44 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{76E69AA0-8C5A-4F76-8561-B8089FFA8D79}</ProjectGuid> + <OutputType>Exe</OutputType> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="$(MSBuildProjectName).cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_7907/GitHub_7907.cs b/tests/src/JIT/Regression/JitBlue/GitHub_7907/GitHub_7907.cs new file mode 100644 index 0000000000..32ea54c663 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_7907/GitHub_7907.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.CompilerServices; + +#pragma warning disable 472 + +public class Bug7907 +{ + int _position = 10; + + [MethodImpl(MethodImplOptions.NoInlining)] + public static int G(int z, ref int r) + { + r -= z; + return 1; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int F0(int count) + { + int initialCount = count; + + _position += G(_position, ref count); + + if (initialCount == count) + { + count--; + } + + return initialCount - count; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public int F1(int count) + { + // " != null" is known to be true - just to remove control flow + // since that by itself may force spilling and mask the bug + count -= (_position += G(_position, ref count)) != null ? count : 1; + + return count; + } + + public static int Main(string[] args) + { + int result0 = new Bug7907().F0(10); + int result1 = new Bug7907().F1(10); + Console.WriteLine("R0={0} R1={1}", result0, result1); + return (result0 == 10 && result1 == 10 ? 100 : -1); + } +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_7907/GitHub_7907.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_7907/GitHub_7907.csproj new file mode 100644 index 0000000000..5c86d0f679 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_7907/GitHub_7907.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>pdbonly</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="$(MSBuildProjectName).cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8133/GitHub_8133.il b/tests/src/JIT/Regression/JitBlue/GitHub_8133/GitHub_8133.il new file mode 100644 index 0000000000..be6720d88a --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8133/GitHub_8133.il @@ -0,0 +1,112 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +.assembly extern mscorlib {} +.assembly a {} + +// The original repro for this test was SBCG due to incorrect computation of value numbers for the ref-typed locals +// in Test::Main(). Despite the fact that each local refers to a different array element, all of the locals were +// assigned the same value number. + +.class Test extends [mscorlib]System.Object +{ + .method static void Equal(int32 i, int32 j) cil noinlining + { + ldarg.0 + ldarg.1 + bne.un.s fail + ret + +fail: + newobj instance void [mscorlib]System.Exception::.ctor() + throw + } + + .method static !!0& Add<T>(!!0& addr, int32 offset) + { + ldarg.0 + ldarg.1 + sizeof !!0 + conv.i + mul + add + ret + } + + .method public hidebysig static int32 RefAdd() cil managed + { + .entrypoint + + .locals init ( + [0] int32[] a, + [1] int32& r1, + [2] int32& r2, + [3] int32& r3) + + ldc.i4.4 + newarr [mscorlib]System.Int32 + dup + ldtoken field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=16' '<PrivateImplementationDetails>'::'6E9F9131664668938673AFE814BBDE210C6AE91F' + call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle) + stloc.0 + + ldloc.0 + ldc.i4.0 + ldelema [mscorlib]System.Int32 + ldc.i4.1 + call !!0& Test::Add<int32>(!!0&, int32) + stloc.1 + ldc.i4 0x234 + ldloc.1 + ldind.i4 + call void Test::Equal(int32, int32) + + ldloc.1 + ldc.i4.2 + call !!0& Test::Add<int32>(!!0&, int32) + stloc.2 + ldc.i4 0x456 + ldloc.2 + ldind.i4 + call void Test::Equal(int32, int32) + + ldloc.2 + ldc.i4.s -3 + call !!0& Test::Add<int32>(!!0&, int32) + stloc.3 + ldc.i4 0x123 + ldloc.3 + ldind.i4 + call void Test::Equal(int32, int32) + + ldc.i4 100 + ret + } +} + +.class private auto ansi sealed '<PrivateImplementationDetails>' + extends [mscorlib]System.Object +{ + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .class explicit ansi sealed nested private '__StaticArrayInitTypeSize=16' + extends [mscorlib]System.ValueType + { + .pack 1 + .size 16 + } + + .field static assembly initonly int32 '4C55E5E5FC2235CC8C201E69A345F7FAB3FB46FA' at I_000054DC + .field static assembly initonly int64 '67423EBFA8454F19AC6F4686D6C0DC731A3DDD6B' at I_000054E4 + .field static assembly initonly valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=16' '6E9F9131664668938673AFE814BBDE210C6AE91F' at I_000054EC + .field static assembly initonly int32 '9BCE73D0C8B9ECA4F24154F3BD3B8AA473B1C3A9' at I_000054FC +} + +.data cil I_000054DC = bytearray ( + 42 42 42 42) // BBBB +.data cil I_000054E4 = bytearray ( + 00 01 02 03 04 05 06 07) +.data cil I_000054EC = bytearray ( + 23 01 00 00 34 02 00 00 45 03 00 00 56 04 00 00) // #...4...E...V... +.data cil I_000054FC = bytearray ( + 12 34 56 78) // .4Vx diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8133/GitHub_8133.ilproj b/tests/src/JIT/Regression/JitBlue/GitHub_8133/GitHub_8133.ilproj new file mode 100644 index 0000000000..3d8d22ec87 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8133/GitHub_8133.ilproj @@ -0,0 +1,41 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="GitHub_8133.il" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8170/GitHub_8170.cs b/tests/src/JIT/Regression/JitBlue/GitHub_8170/GitHub_8170.cs new file mode 100644 index 0000000000..d3fe8d9cf3 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8170/GitHub_8170.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Runtime.CompilerServices; + +// This test checks for proper behavior w.r.t. overflow for expressions of the form `val % constant` where `val` is an +// unsigned long and `constant` is a 32- or 64-bit integer constant in the range [2,0x3fffffff]. These expressions +// should never produce an overflow exception. + +static class C +{ + [MethodImpl(MethodImplOptions.NoInlining)] + static uint M(ulong l) + { + return (uint)(l % 10000000); + } + + static int Main() + { + return M(ulong.MaxValue) == 9551615 ? 100 : 101; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8170/GitHub_8170.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_8170/GitHub_8170.csproj new file mode 100644 index 0000000000..81aa7299d0 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8170/GitHub_8170.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="GitHub_8170.cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8220/GitHub_8220.cs b/tests/src/JIT/Regression/JitBlue/GitHub_8220/GitHub_8220.cs new file mode 100644 index 0000000000..f38d5ba698 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8220/GitHub_8220.cs @@ -0,0 +1,170 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// Regression test for Vector3 intrinsics using upper non-zero'd bits from +// a byref return. + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Numerics; + +namespace Test +{ + + public class Program + { + static Random random; + + static Program() + { + random = new Random(1); + } + + [MethodImpl( MethodImplOptions.NoInlining )] + public static double StackScribble() + { + double d1 = random.NextDouble(); + double d2 = random.NextDouble(); + double d3 = random.NextDouble(); + double d4 = random.NextDouble(); + double d5 = random.NextDouble(); + double d6 = random.NextDouble(); + double d7 = random.NextDouble(); + double d8 = random.NextDouble(); + double d9 = random.NextDouble(); + double d10 = random.NextDouble(); + double d11 = random.NextDouble(); + double d12 = random.NextDouble(); + double d13 = random.NextDouble(); + double d14 = random.NextDouble(); + double d15 = random.NextDouble(); + double d16 = random.NextDouble(); + double d17 = random.NextDouble(); + double d18 = random.NextDouble(); + double d19 = random.NextDouble(); + double d20 = random.NextDouble(); + double d21 = random.NextDouble(); + double d22 = random.NextDouble(); + double d23 = random.NextDouble(); + double d24 = random.NextDouble(); + double d25 = random.NextDouble(); + double d26 = random.NextDouble(); + double d27 = random.NextDouble(); + double d28 = random.NextDouble(); + double d29 = random.NextDouble(); + double d30 = random.NextDouble(); + double d31 = random.NextDouble(); + double d32 = random.NextDouble(); + double d33 = random.NextDouble(); + double d34 = random.NextDouble(); + double d35 = random.NextDouble(); + double d36 = random.NextDouble(); + double d37 = random.NextDouble(); + double d38 = random.NextDouble(); + double d39 = random.NextDouble(); + double d40 = random.NextDouble(); + return d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10 + + d11 + d12 + d13 + d14 + d15 + d16 + d17 + d18 + d19 + d20 + + d21 + d22 + d23 + d24 + d25 + d26 + d27 + d28 + d29 + d20 + + d31 + d32 + d33 + d34 + d35 + d36 + d37 + d38 + d39 + d40; + } + + [MethodImpl( MethodImplOptions.NoInlining )] + public static Vector3 getTestValue(float f1, float f2, float f3) + { + return new Vector3(f1, f2, f3); + } + + public static bool Check(float value, float expectedValue) + { + // These may differ in the last place. + float expectedValueLow; + float expectedValueHigh; + + unsafe + { + UInt32 expectedValueUInt = *(UInt32*)&expectedValue; + UInt32 expectedValueUIntLow = (expectedValueUInt == 0) ? 0 : expectedValueUInt - 1; + UInt32 expectedValueUIntHigh = (expectedValueUInt == 0xffffffff) ? 0xffffffff : expectedValueUInt + 1; + expectedValueLow = *(float*)&expectedValueUIntLow; + expectedValueHigh = *(float*)&expectedValueUIntHigh; + } + float errorMargin = Math.Abs(expectedValueHigh - expectedValueLow); + if (Math.Abs(value - expectedValue) > errorMargin) + { + return false; + } + return true; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static int testDotProduct(Vector3 v0) + { + float f1 = (float)random.NextDouble(); + float f2 = (float)random.NextDouble(); + float f3 = (float)random.NextDouble(); + + Vector3 v1 = Vector3.Normalize(getTestValue(f1, f2, f3) - v0); + Vector3 v2 = new Vector3(f1, f2, f3) - v0; + v2 = v2 / v2.Length(); + + if (!Check(v1.X, v2.X) || !Check(v1.Y, v2.Y) || !Check(v1.Z, v2.Z)) + { + Console.WriteLine("Vectors do not match " + v1 + v2); + return -1; + } + + return 100; + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static int testEquals(Vector3 v0) + { + float f1 = (float)random.NextDouble(); + float f2 = (float)random.NextDouble(); + float f3 = (float)random.NextDouble(); + + Vector3 v1 = new Vector3(f1, f2, f3) - v0; + bool result = v1.Equals(getTestValue(f1, f2, f3) - v0); + + if ((result == false) || !v1.Equals(getTestValue(f1, f2, f3) - v0)) + { + Console.WriteLine("Equals returns wrong value " + v1); + return -1; + } + + return 100; + } + + public static int Main() + { + int returnValue = 100; + Console.WriteLine("Testing Dot Product"); + for (int i = 0; i < 10; i++) + { + StackScribble(); + if (testDotProduct(new Vector3(1.0F, 2.0F, 3.0F)) != 100) + { + Console.WriteLine("Failed on iteration " + i); + returnValue = -1; + break; + } + } + Console.WriteLine("Testing Equals"); + for (int i = 0; i < 10; i++) + { + StackScribble(); + if (testEquals(new Vector3(1.0F, 2.0F, 3.0F)) != 100) + { + Console.WriteLine("Failed on iteration " + i); + returnValue = -1; + break; + } + } + return returnValue; + } + } +} + diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8220/GitHub_8220.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_8220/GitHub_8220.csproj new file mode 100644 index 0000000000..939d0106ed --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8220/GitHub_8220.csproj @@ -0,0 +1,45 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{76E69AA0-8C5A-4F76-8561-B8089FFA8D79}</ProjectGuid> + <OutputType>Exe</OutputType> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + <AllowUnsafeBlocks>True</AllowUnsafeBlocks> + </PropertyGroup> + <ItemGroup> + <Compile Include="$(MSBuildProjectName).cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8231/GitHub_8231.cs b/tests/src/JIT/Regression/JitBlue/GitHub_8231/GitHub_8231.cs new file mode 100644 index 0000000000..4d2ec7628a --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8231/GitHub_8231.cs @@ -0,0 +1,62 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Numerics; +using System.Runtime.CompilerServices; + +namespace N +{ + public static class C + { + // This is a regression test for a failure in loop unrolling when + // the unrolled loop contains a switch statement. + [MethodImpl(MethodImplOptions.NoInlining)] + static int Test() + { + int s = 0; + + // Loop to some Vector<T>.Count to trigger unrolling. + for (int i = 0; i < Vector<int>.Count; i++) + { + // Loop contains switch; the bug was that the clones + // of the switch were all sharing its BBswtDesc instead + // of getting their own, so updates to their jump targets + // were incorrectly shared. + switch (i) + { + case 1: s += 4; break; + case 2: s += 2; break; + case 3: s += i; break; + } + } + + return s; + } + + public static int Main(string[] args) + { + int result = Test(); + + // Expected result is a function of Vector<int>.Count. + int expected; + switch(Vector<int>.Count) + { + case 1: + expected = 4; + break; + case 2: + expected = 6; + break; + default: + expected = 9; + break; + } + + // Return 100 on success (result == expected), other + // values on failure. + return 100 + result - expected; + } + } +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8231/GitHub_8231.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_8231/GitHub_8231.csproj new file mode 100644 index 0000000000..844638fe1b --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8231/GitHub_8231.csproj @@ -0,0 +1,39 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{2649FAFE-07BF-4F93-8120-BA9A69285ABB}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <Compile Include="GitHub_8231.cs" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)benchmark\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)benchmark\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8460/GitHub_8460.cs b/tests/src/JIT/Regression/JitBlue/GitHub_8460/GitHub_8460.cs new file mode 100644 index 0000000000..f5c9aa281b --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8460/GitHub_8460.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace bug +{ + class Program + { + static int Pass = 100; + static int Fail = -1; + + // This test is meant to check that in case of + // GT_EQ/NE(shift, 0), JIT doesn't optimize out + // 'test' instruction incorrectly, because shift + // operations on xarch don't modify flags if the + // shift count is zero. + static int Main(string[] args) + { + // Absolute bits + int bitCount = 0; + while ((0 != (100 >> bitCount)) && (31 > bitCount)) + { + bitCount++; + } + // Sign bit + bitCount++; + + if (bitCount != 8) + { + return Fail; + } + + return Pass; + } + } +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8460/GitHub_8460.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_8460/GitHub_8460.csproj new file mode 100644 index 0000000000..b174dea98e --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8460/GitHub_8460.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="$(MSBuildProjectName).cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8599/GitHub_8599.cs b/tests/src/JIT/Regression/JitBlue/GitHub_8599/GitHub_8599.cs new file mode 100644 index 0000000000..95ff457620 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8599/GitHub_8599.cs @@ -0,0 +1,42 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.CompilerServices; + +// TreeNodeInfoInitCmp attempts to eliminate the cast from cmp(cast<ubyte>(x), icon) +// by narrowing the compare to ubyte. This should only happen if the constant fits in +// a byte so it can be narrowed too, otherwise codegen produces an int sized compare. + +class Program +{ + [MethodImpl(MethodImplOptions.NoInlining)] + static int GetValue() => 301; + + static void Escape(ref int x) + { + } + + static int Main() + { + if ((byte)GetValue() > 300) + { + return -1; + } + + int x = GetValue(); + Escape(ref x); + if ((byte)x > 300) + { + return -2; + } + + if ((byte)(GetValue() | 2) > 300) + { + return -3; + } + + return 100; + } +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_8599/GitHub_8599.csproj b/tests/src/JIT/Regression/JitBlue/GitHub_8599/GitHub_8599.csproj new file mode 100644 index 0000000000..b174dea98e --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_8599/GitHub_8599.csproj @@ -0,0 +1,46 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType></DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="$(MSBuildProjectName).cs" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <PropertyGroup> + <ProjectJson>$(JitPackagesConfigFileDirectory)minimal\project.json</ProjectJson> + <ProjectLockJson>$(JitPackagesConfigFileDirectory)minimal\project.lock.json</ProjectLockJson> + </PropertyGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_CoreRT_2073/GitHub_CoreRT_2073.il b/tests/src/JIT/Regression/JitBlue/GitHub_CoreRT_2073/GitHub_CoreRT_2073.il new file mode 100644 index 0000000000..28adbc49bb --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_CoreRT_2073/GitHub_CoreRT_2073.il @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +// Test for a issue when tail call with small return type +// doesn't pass tail call pattern assert. +// In addition there is "call->branch on return->return" tail call pattern check. + + +.assembly extern mscorlib {} + +.assembly GitHub_CoreRT_2073.exe {} + +.class public Test +{ + +.method private hidebysig static bool tailAsgReturn(int32 deep) cil managed +{ + // Code size 24 (0x18) + .maxstack 20 + IL_0000: ldarg.0 + IL_0001: ldc.i4.s -100 + IL_0003: bgt.s IL_0007 + IL_0005: ldc.i4.1 + IL_0006: ret + IL_0007: ldarg.0 + IL_0008: ldc.i4.0 + IL_0009: bgt.s IL_000f + + IL_000a: ldarg.0 + IL_000b: ldc.i4.1 + IL_000c: sub + IL_000d: call bool Test::tailAsgReturn(int32) + IL_000e: br IL_0017 + IL_000f: ldarg.0 + IL_0010: ldc.i4.2 + IL_0011: sub + IL_0012: call bool Test::tailAsgReturn(int32) + IL_0017: ret +} // end of method Test::tailAsgReturn + +.method public hidebysig static int32 Main(string[] args) cil managed +{ + .entrypoint + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldc.i4.s 100 + IL_0002: call bool Test::tailAsgReturn(int32) + IL_0007: brtrue.s IL_000b + IL_0009: ldc.i4.m1 + IL_000a: ret + IL_000b: ldc.i4.s 100 + IL_000d: ret +} // end of method Test::Main +} diff --git a/tests/src/JIT/Regression/JitBlue/GitHub_CoreRT_2073/GitHub_CoreRT_2073.ilproj b/tests/src/JIT/Regression/JitBlue/GitHub_CoreRT_2073/GitHub_CoreRT_2073.ilproj new file mode 100644 index 0000000000..fe8a3d3947 --- /dev/null +++ b/tests/src/JIT/Regression/JitBlue/GitHub_CoreRT_2073/GitHub_CoreRT_2073.ilproj @@ -0,0 +1,38 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>$(MSBuildProjectName)</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <PropertyGroup> + <DebugType>None</DebugType> + <Optimize>True</Optimize> + </PropertyGroup> + <ItemGroup> + <Compile Include="GitHub_CoreRT_2073.il" /> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> + <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> + </PropertyGroup> +</Project> diff --git a/tests/src/JIT/Regression/VS-ia64-JIT/V2.0-Beta2/b311420/b311420.csproj b/tests/src/JIT/Regression/VS-ia64-JIT/V2.0-Beta2/b311420/b311420.csproj index b12149b936..77a35cdd82 100644 --- a/tests/src/JIT/Regression/VS-ia64-JIT/V2.0-Beta2/b311420/b311420.csproj +++ b/tests/src/JIT/Regression/VS-ia64-JIT/V2.0-Beta2/b311420/b311420.csproj @@ -14,6 +14,9 @@ <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + + <!-- NOTE: this test simply takes too long to complete under GC stress; it is not fundamentally incompatible --> + <GCStressIncompatible Condition="'$(Platform)' == 'x86'">true</GCStressIncompatible> </PropertyGroup> <!-- Default configurations to help VS understand the configurations --> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> @@ -42,4 +45,4 @@ <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> </PropertyGroup> -</Project>
\ No newline at end of file +</Project> diff --git a/tests/src/JIT/SIMD/Vector3Interop.cs b/tests/src/JIT/SIMD/Vector3Interop.cs index fa6f8700d5..147adf44a8 100755 --- a/tests/src/JIT/SIMD/Vector3Interop.cs +++ b/tests/src/JIT/SIMD/Vector3Interop.cs @@ -112,7 +112,7 @@ class PInvokeTest // Expected return value = 1 + 2 + 3 + 10 + 11 + 12 = 39 if (nativeCall_PInvoke_Vector3Arg(iv, v1, str, v2) != 39) { - Console.Write("PInvoke Vector3Arg test failed\n"); + Console.WriteLine("PInvoke Vector3Arg test failed"); return false; } } @@ -130,7 +130,7 @@ class PInvokeTest f6, v2, // stack f7, f8); // stack if (sum != 1002) { - Console.Write("PInvoke Vector3Arg_Unix test failed\n"); + Console.WriteLine("PInvoke Vector3Arg_Unix test failed"); return false; } } @@ -151,7 +151,7 @@ class PInvokeTest v3, // stack f9); // stack if (sum != 1090) { - Console.Write("PInvoke Vector3Arg_Unix2 test failed\n"); + Console.WriteLine("PInvoke Vector3Arg_Unix2 test failed"); return false; } } diff --git a/tests/src/JIT/SIMD/VectorDot.cs b/tests/src/JIT/SIMD/VectorDot.cs index 2efe79e5ab..22c1493394 100644 --- a/tests/src/JIT/SIMD/VectorDot.cs +++ b/tests/src/JIT/SIMD/VectorDot.cs @@ -113,12 +113,17 @@ internal partial class VectorTest if (VectorDotTest<ulong>.VectorDot(3ul, 2ul, 6ul * (ulong)Vector<ulong>.Count) != Pass) returnVal = Fail; JitLog jitLog = new JitLog(); - // Dot is only recognized as an intrinsic for floating point element types. + // Dot is only recognized as an intrinsic for floating point element types + // and Vector<int> on AVX. if (!jitLog.Check("Dot", "Single")) returnVal = Fail; if (!jitLog.Check("Dot", "Double")) returnVal = Fail; if (!jitLog.Check("System.Numerics.Vector4:Dot")) returnVal = Fail; if (!jitLog.Check("System.Numerics.Vector3:Dot")) returnVal = Fail; if (!jitLog.Check("System.Numerics.Vector2:Dot")) returnVal = Fail; + if (Vector<int>.Count == 8) + { + if (!jitLog.Check("Dot", "Int32")) returnVal = Fail; + } jitLog.Dispose(); return returnVal; diff --git a/tests/src/JIT/SIMD/VectorIntEquals.cs b/tests/src/JIT/SIMD/VectorIntEquals.cs index bbbbbe519d..fae49aac1d 100644 --- a/tests/src/JIT/SIMD/VectorIntEquals.cs +++ b/tests/src/JIT/SIMD/VectorIntEquals.cs @@ -17,12 +17,67 @@ internal partial class VectorTest Vector<int> B = new Vector<int>(3); Vector<int> C = new Vector<int>(5); - bool result = A.Equals(B); - if (!result) return Fail; + if (!result) + { + return Fail; + } result = A.Equals(C); - if (result) return Fail; + if (result) + { + return Fail; + } + + if (A.Equals(Vector<int>.Zero)) + { + return Fail; + } + + if (!Vector<int>.Zero.Equals(Vector<int>.Zero)) + { + return Fail; + } + + if (Vector<int>.Zero.Equals(B)) + { + return Fail; + } + + if (!(A == B)) + { + return Fail; + } + + if (A == Vector<int>.Zero) + { + return Fail; + } + + if (!(A != Vector<int>.Zero)) + { + return Fail; + } + + if (A != B) + { + return Fail; + } + + if (!(A != C)) + { + return Fail; + } + + if (!(Vector<int>.Zero != A)) + { + return Fail; + } + + if (Vector<int>.Zero != Vector<int>.Zero) + { + return Fail; + } return Pass; } diff --git a/tests/src/JIT/SIMD/VectorUtil.cs b/tests/src/JIT/SIMD/VectorUtil.cs index d1b669df29..6501aac767 100644 --- a/tests/src/JIT/SIMD/VectorUtil.cs +++ b/tests/src/JIT/SIMD/VectorUtil.cs @@ -309,7 +309,7 @@ class JitLog : IDisposable } if (simdIntrinsicsSupported && methodFound) { - Console.WriteLine("Method " + method + " was compiled but should not have been\n"); + Console.WriteLine("Method " + method + " was compiled but should not have been"); return false; } // Useful when developing / debugging just to be sure that we reached here: diff --git a/tests/src/JIT/config/benchmark+roslyn/project.json b/tests/src/JIT/config/benchmark+roslyn/project.json index 3fc4bd5809..e50dfd25c1 100644 --- a/tests/src/JIT/config/benchmark+roslyn/project.json +++ b/tests/src/JIT/config/benchmark+roslyn/project.json @@ -1,29 +1,29 @@ { "dependencies": { "Microsoft.CodeAnalysis.Compilers": "1.1.1", - "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0035", - "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0035", - "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0035", - "Microsoft.NETCore.Platforms": "1.1.0", - "System.Console": "4.3.0", - "System.Dynamic.Runtime": "4.3.0", - "System.Linq": "4.3.0", - "System.IO.FileSystem": "4.3.0", - "System.Numerics.Vectors": "4.3.0", - "System.Reflection": "4.3.0", - "System.Reflection.Extensions": "4.3.0", - "System.Reflection.TypeExtensions": "4.3.0", - "System.Runtime": "4.3.0", - "System.Runtime.Extensions": "4.3.0", - "System.Runtime.Numerics": "4.3.0", - "System.Text.RegularExpressions": "4.3.0", - "System.Threading": "4.3.0", - "System.Threading.Tasks": "4.3.0", - "System.Threading.Tasks.Parallel": "4.3.0", - "System.Security.Cryptography.Algorithms": "4.3.0", - "xunit": "2.1.0", - "xunit.console.netcore": "1.0.2-prerelease-00101", - "xunit.runner.utility": "2.1.0" + "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0040", + "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0040", + "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040", + "Microsoft.NETCore.Platforms": "1.2.0-beta-24820-02", + "System.Console": "4.4.0-beta-24820-02", + "System.Dynamic.Runtime": "4.4.0-beta-24820-02", + "System.Linq": "4.4.0-beta-24820-02", + "System.IO.FileSystem": "4.4.0-beta-24820-02", + "System.Numerics.Vectors": "4.4.0-beta-24820-02", + "System.Reflection": "4.4.0-beta-24820-02", + "System.Reflection.Extensions": "4.4.0-beta-24820-02", + "System.Reflection.TypeExtensions": "4.4.0-beta-24820-02", + "System.Runtime": "4.4.0-beta-24820-02", + "System.Runtime.Extensions": "4.4.0-beta-24820-02", + "System.Runtime.Numerics": "4.4.0-beta-24820-02", + "System.Text.RegularExpressions": "4.4.0-beta-24820-02", + "System.Threading": "4.4.0-beta-24820-02", + "System.Threading.Tasks": "4.4.0-beta-24820-02", + "System.Threading.Tasks.Parallel": "4.4.0-beta-24820-02", + "System.Security.Cryptography.Algorithms": "4.4.0-beta-24820-02", + "xunit": "2.2.0-beta2-build3300", + "xunit.console.netcore": "1.0.2-prerelease-00177", + "xunit.runner.utility": "2.2.0-beta2-build3300" }, "frameworks": { "netstandard1.4": { diff --git a/tests/src/JIT/config/benchmark+serialize/project.json b/tests/src/JIT/config/benchmark+serialize/project.json index e7e1853000..ac24df1167 100644 --- a/tests/src/JIT/config/benchmark+serialize/project.json +++ b/tests/src/JIT/config/benchmark+serialize/project.json @@ -1,26 +1,29 @@ { "dependencies": { - "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0035", - "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0035", - "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0035", - "Microsoft.NETCore.Platforms": "1.1.0", + "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0040", + "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0040", + "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040", + "Microsoft.NETCore.Platforms": "1.2.0-beta-24820-02", "Newtonsoft.Json": "7.0.1", - "System.Console": "4.3.0", - "System.IO": "4.3.0", - "System.IO.FileSystem": "4.3.0", - "System.Linq": "4.3.0", - "System.ObjectModel": "4.3.0", - "System.Dynamic.Runtime": "4.3.0", - "System.Runtime": "4.3.0", - "System.Runtime.Serialization.Json": "4.3.0", - "System.Runtime.Serialization.Primitives": "4.1.1", - "System.Runtime.Serialization.Xml": "4.3.0", - "System.Text.RegularExpressions": "4.3.0", - "System.Xml.XmlDocument": "4.3.0", - "System.Xml.XmlSerializer": "4.3.0", - "xunit": "2.1.0", - "xunit.console.netcore": "1.0.2-prerelease-00101", - "xunit.runner.utility": "2.1.0" + "System.Console": "4.4.0-beta-24820-02", + "System.IO": "4.4.0-beta-24820-02", + "System.IO.FileSystem": "4.4.0-beta-24820-02", + "System.Linq": "4.4.0-beta-24820-02", + "System.ObjectModel": "4.4.0-beta-24820-02", + "System.Dynamic.Runtime": "4.4.0-beta-24820-02", + "System.Reflection": "4.4.0-beta-24820-02", + "System.Reflection.Extensions": "4.4.0-beta-24820-02", + "System.Reflection.TypeExtensions": "4.4.0-beta-24820-02", + "System.Runtime": "4.4.0-beta-24820-02", + "System.Runtime.Serialization.Json": "4.4.0-beta-24820-02", + "System.Runtime.Serialization.Primitives": "4.4.0-beta-24820-02", + "System.Runtime.Serialization.Xml": "4.4.0-beta-24820-02", + "System.Text.RegularExpressions": "4.4.0-beta-24820-02", + "System.Xml.XmlDocument": "4.4.0-beta-24820-02", + "System.Xml.XmlSerializer": "4.4.0-beta-24820-02", + "xunit": "2.2.0-beta2-build3300", + "xunit.console.netcore": "1.0.2-prerelease-00177", + "xunit.runner.utility": "2.2.0-beta2-build3300" }, "frameworks": { "netstandard1.4": { diff --git a/tests/src/JIT/config/benchmark/project.json b/tests/src/JIT/config/benchmark/project.json index 8f1493c32d..97234d329e 100644 --- a/tests/src/JIT/config/benchmark/project.json +++ b/tests/src/JIT/config/benchmark/project.json @@ -1,29 +1,32 @@ { "dependencies": { - "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0035", - "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0035", - "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0035", - "Microsoft.NETCore.Platforms": "1.1.0", - "System.Collections.NonGeneric": "4.3.0", - "System.Console": "4.3.0", - "System.IO.FileSystem": "4.3.0", - "System.Linq": "4.3.0", - "System.Linq.Expressions": "4.3.0", - "System.Numerics.Vectors": "4.3.0", - "System.Runtime": "4.3.0", - "System.Runtime.Extensions": "4.3.0", - "System.Runtime.Numerics": "4.3.0", - "System.Text.RegularExpressions": "4.3.0", - "System.Threading": "4.3.0", - "System.Threading.Tasks": "4.3.0", - "System.Threading.Tasks.Parallel": "4.3.0", - "System.Diagnostics.Process": "4.3.0", - "System.Xml.XmlDocument": "4.3.0", - "System.Xml.XPath": "4.3.0", - "System.Xml.XPath.XmlDocument": "4.3.0", - "xunit": "2.1.0", - "xunit.console.netcore": "1.0.2-prerelease-00101", - "xunit.runner.utility": "2.1.0" + "Microsoft.DotNet.xunit.performance": "1.0.0-alpha-build0040", + "Microsoft.DotNet.xunit.performance.analysis": "1.0.0-alpha-build0040", + "Microsoft.DotNet.xunit.performance.runner.Windows": "1.0.0-alpha-build0040", + "Microsoft.NETCore.Platforms": "1.2.0-beta-24820-02", + "System.Collections.NonGeneric": "4.4.0-beta-24820-02", + "System.Console": "4.4.0-beta-24820-02", + "System.IO.FileSystem": "4.4.0-beta-24820-02", + "System.Linq": "4.4.0-beta-24820-02", + "System.Linq.Expressions": "4.4.0-beta-24820-02", + "System.Numerics.Vectors": "4.4.0-beta-24820-02", + "System.Reflection": "4.4.0-beta-24820-02", + "System.Reflection.Extensions": "4.4.0-beta-24820-02", + "System.Reflection.TypeExtensions": "4.4.0-beta-24820-02", + "System.Runtime": "4.4.0-beta-24820-02", + "System.Runtime.Extensions": "4.4.0-beta-24820-02", + "System.Runtime.Numerics": "4.4.0-beta-24820-02", + "System.Text.RegularExpressions": "4.4.0-beta-24820-02", + "System.Threading": "4.4.0-beta-24820-02", + "System.Threading.Tasks": "4.4.0-beta-24820-02", + "System.Threading.Tasks.Parallel": "4.4.0-beta-24820-02", + "System.Diagnostics.Process": "4.4.0-beta-24820-02", + "System.Xml.XmlDocument": "4.4.0-beta-24820-02", + "System.Xml.XPath": "4.4.0-beta-24820-02", + "System.Xml.XPath.XmlDocument": "4.4.0-beta-24820-02", + "xunit": "2.2.0-beta2-build3300", + "xunit.console.netcore": "1.0.2-prerelease-00177", + "xunit.runner.utility": "2.2.0-beta2-build3300" }, "frameworks": { "netstandard1.4": { diff --git a/tests/src/JIT/config/extra/project.json b/tests/src/JIT/config/extra/project.json index 92b2fac43a..6268bc58e9 100644 --- a/tests/src/JIT/config/extra/project.json +++ b/tests/src/JIT/config/extra/project.json @@ -1,24 +1,24 @@ { "dependencies": { - "Microsoft.NETCore.Platforms": "1.1.0", - "System.Collections": "4.3.0", - "System.Console": "4.3.0", - "System.Diagnostics.Debug": "4.3.0", - "System.Runtime.InteropServices.RuntimeInformation": "4.3.0", - "System.Diagnostics.Process": "4.3.0", - "System.Globalization": "4.3.0", - "System.IO": "4.3.0", - "System.IO.FileSystem": "4.3.0", - "System.Reflection": "4.3.0", - "System.Reflection.Extensions": "4.3.0", - "System.Reflection.TypeExtensions": "4.3.0", - "System.Runtime": "4.3.0", - "System.Runtime.Extensions": "4.3.0", - "System.Runtime.CompilerServices.Unsafe": "4.3.0", - "System.Runtime.InteropServices": "4.3.0" + "Microsoft.NETCore.Platforms": "1.2.0-beta-24820-02", + "System.Collections": "4.4.0-beta-24820-02", + "System.Console": "4.4.0-beta-24820-02", + "System.Diagnostics.Debug": "4.4.0-beta-24820-02", + "System.Runtime.InteropServices.RuntimeInformation": "4.4.0-beta-24820-02", + "System.Diagnostics.Process": "4.4.0-beta-24820-02", + "System.Globalization": "4.4.0-beta-24820-02", + "System.IO": "4.4.0-beta-24820-02", + "System.IO.FileSystem": "4.4.0-beta-24820-02", + "System.Reflection": "4.4.0-beta-24820-02", + "System.Reflection.Extensions": "4.4.0-beta-24820-02", + "System.Reflection.TypeExtensions": "4.4.0-beta-24820-02", + "System.Runtime": "4.4.0-beta-24820-02", + "System.Runtime.Extensions": "4.4.0-beta-24820-02", + "System.Runtime.CompilerServices.Unsafe": "4.4.0-beta-24820-02", + "System.Runtime.InteropServices": "4.4.0-beta-24820-02" }, "frameworks": { - "netcoreapp1.0": {} + "netcoreapp1.1": {} }, "runtimes": { "win7-x86": {}, diff --git a/tests/src/JIT/config/minimal/project.json b/tests/src/JIT/config/minimal/project.json index 20eded453a..6bc378e4a4 100644 --- a/tests/src/JIT/config/minimal/project.json +++ b/tests/src/JIT/config/minimal/project.json @@ -1,13 +1,13 @@ { "dependencies": { - "Microsoft.NETCore.Platforms": "1.1.0", - "System.Console": "4.3.0", - "System.Runtime": "4.3.0", - "System.Runtime.Extensions": "4.3.0", - "System.Runtime.InteropServices": "4.3.0" + "Microsoft.NETCore.Platforms": "1.2.0-beta-24820-02", + "System.Console": "4.4.0-beta-24820-02", + "System.Runtime": "4.4.0-beta-24820-02", + "System.Runtime.Extensions": "4.4.0-beta-24820-02", + "System.Runtime.InteropServices": "4.4.0-beta-24820-02" }, "frameworks": { - "netcoreapp1.0": {} + "netcoreapp1.1": {} }, "runtimes": { "win7-x86": {}, diff --git a/tests/src/JIT/config/threading+thread/project.json b/tests/src/JIT/config/threading+thread/project.json index 4efc76cf00..f6576f154d 100644 --- a/tests/src/JIT/config/threading+thread/project.json +++ b/tests/src/JIT/config/threading+thread/project.json @@ -1,15 +1,15 @@ { "dependencies": { - "Microsoft.NETCore.Platforms": "1.1.0", - "System.Console": "4.3.0", - "System.Numerics.Vectors": "4.3.0", - "System.Runtime": "4.3.0", - "System.Runtime.Extensions": "4.3.0", - "System.Threading": "4.3.0", - "System.Threading.Thread": "4.3.0" + "Microsoft.NETCore.Platforms": "1.2.0-beta-24820-02", + "System.Console": "4.4.0-beta-24820-02", + "System.Numerics.Vectors": "4.4.0-beta-24820-02", + "System.Runtime": "4.4.0-beta-24820-02", + "System.Runtime.Extensions": "4.4.0-beta-24820-02", + "System.Threading": "4.4.0-beta-24820-02", + "System.Threading.Thread": "4.4.0-beta-24820-02" }, "frameworks": { - "netcoreapp1.0": {} + "netcoreapp1.1": {} }, "runtimes": { "win7-x86": {}, diff --git a/tests/src/JIT/config/threading/project.json b/tests/src/JIT/config/threading/project.json index b0478ce429..e62d3551a4 100644 --- a/tests/src/JIT/config/threading/project.json +++ b/tests/src/JIT/config/threading/project.json @@ -1,13 +1,13 @@ { "dependencies": { - "Microsoft.NETCore.Platforms": "1.1.0", - "System.Console": "4.3.0", - "System.Runtime": "4.3.0", - "System.Runtime.Extensions": "4.3.0", - "System.Threading": "4.3.0" + "Microsoft.NETCore.Platforms": "1.2.0-beta-24820-02", + "System.Console": "4.4.0-beta-24820-02", + "System.Runtime": "4.4.0-beta-24820-02", + "System.Runtime.Extensions": "4.4.0-beta-24820-02", + "System.Threading": "4.4.0-beta-24820-02" }, "frameworks": { - "netcoreapp1.0": {} + "netcoreapp1.1": {} }, "runtimes": { "win7-x86": {}, diff --git a/tests/src/JIT/jit64/opt/cse/HugeArray.csproj b/tests/src/JIT/jit64/opt/cse/HugeArray.csproj index 8926c0f997..166482bcc1 100644 --- a/tests/src/JIT/jit64/opt/cse/HugeArray.csproj +++ b/tests/src/JIT/jit64/opt/cse/HugeArray.csproj @@ -14,6 +14,9 @@ <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + + <!-- NOTE: this test simply takes too long to complete under GC stress; it is not fundamentally incompatible --> + <GCStressIncompatible Condition="'$(Platform)' == 'x86'">true</GCStressIncompatible> </PropertyGroup> <!-- Default configurations to help VS understand the configurations --> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> @@ -42,4 +45,4 @@ <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> <PropertyGroup Condition=" '$(MsBuildProjectDirOverride)' != '' "> </PropertyGroup> -</Project>
\ No newline at end of file +</Project> diff --git a/tests/src/JIT/jit64/verif/sniff/fg/ver_fg_13.il b/tests/src/JIT/jit64/verif/sniff/fg/ver_fg_13.il index 9e422bbdab..5ad48d1878 100644 --- a/tests/src/JIT/jit64/verif/sniff/fg/ver_fg_13.il +++ b/tests/src/JIT/jit64/verif/sniff/fg/ver_fg_13.il @@ -11,12 +11,7 @@ .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A ) .ver 4:0:0:0 } -.assembly test -{ - .custom instance void [mscorlib]System.Security.AllowPartiallyTrustedCallersAttribute::.ctor() = ( 01 00 01 00 00 ) - -} - +.assembly test { } .module ver_fg_13.exe diff --git a/tests/src/JIT/opt/Inline/regression/mismatch32/mismatch32.il b/tests/src/JIT/opt/Inline/regression/mismatch32/mismatch32.il index e23b0a8346..73730d72dd 100644 --- a/tests/src/JIT/opt/Inline/regression/mismatch32/mismatch32.il +++ b/tests/src/JIT/opt/Inline/regression/mismatch32/mismatch32.il @@ -5,6 +5,10 @@ // When the jit considers inlining B it can get itself into // trouble because of the type mismatch. This test tries to // ensure the jit backs out of the inline successfully. +// +// By default (when no args are passed) execution avoids +// the problematic callsite, and the app should run without +// failing. .assembly extern mscorlib { } .assembly extern System.Console @@ -39,7 +43,7 @@ ldarg.0 ldlen ldc.i4 1 - bgt DONE + blt DONE newobj instance void F::.ctor() ldc.i4 33 call int32 B(int32, int32) diff --git a/tests/src/JIT/opt/Inline/regression/mismatch64/mismatch64.il b/tests/src/JIT/opt/Inline/regression/mismatch64/mismatch64.il index f952856909..ba336c06c9 100644 --- a/tests/src/JIT/opt/Inline/regression/mismatch64/mismatch64.il +++ b/tests/src/JIT/opt/Inline/regression/mismatch64/mismatch64.il @@ -5,6 +5,10 @@ // When the jit considers inlining B it can get itself into // trouble because of the type mismatch. This test tries to // ensure the jit backs out of the inline successfully. +// +// By default (when no args are passed) execution avoids +// the problematic callsite, and the app should run without +// failing. .assembly extern mscorlib { } .assembly extern System.Console @@ -39,7 +43,7 @@ ldarg.0 ldlen ldc.i4 1 - bgt DONE + blt DONE newobj instance void F::.ctor() ldc.i8 44 call int64 B(int64, int64) diff --git a/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il b/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il index 9c5fcfdf29..763d95f628 100644 --- a/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il +++ b/tests/src/JIT/opt/Tailcall/TailcallVerifyWithPrefix.il @@ -5610,6 +5610,9 @@ .method public hidebysig instance void Caller1() cil managed { + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 53 (0x35) .maxstack 8 IL_0000: ldc.i4.0 @@ -5633,6 +5636,9 @@ .method public hidebysig instance void Caller1Recursive() cil managed { + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 55 (0x37) .maxstack 8 IL_0000: ldc.i4.0 @@ -5670,6 +5676,9 @@ .method private hidebysig instance void Callee1Recursive(int32 i) cil managed { + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 93 (0x5d) .maxstack 3 .locals init ([0] string stackTrace, @@ -5805,6 +5814,9 @@ Caller1(!V arg1, !K arg2) cil managed { + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 54 (0x36) .maxstack 8 IL_0000: ldc.i4.0 @@ -6016,6 +6028,9 @@ .method private hidebysig static void Caller2() cil managed { + // This method depends on JIT compiler doing automatic tail call, which isn't supported by Ready-to-Run. + .custom instance void System.Runtime.BypassReadyToRunAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 52 (0x34) .maxstack 8 IL_0000: ldc.i4.0 @@ -10376,6 +10391,21 @@ .field static assembly valuetype '<PrivateImplementationDetails>{D1242658-CA16-4D11-A740-6635F112F4B5}'/'__StaticArrayInitTypeSize=20' '$$method0x6000076-1' at I_00005C00 } // end of class '<PrivateImplementationDetails>{D1242658-CA16-4D11-A740-6635F112F4B5}' +.class private auto ansi sealed beforefieldinit System.Runtime.BypassReadyToRunAttribute + extends [mscorlib]System.Attribute +{ + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Attribute::.ctor() + IL_0006: ret + } // end of method BypassReadyToRunAttribute::.ctor + +} // end of class System.Runtime.BypassReadyToRunAttribute + // ============================================================= diff --git a/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_d.csproj b/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_d.csproj index da9a36e07d..4a5818f410 100644 --- a/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_d.csproj +++ b/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_d.csproj @@ -14,6 +14,9 @@ <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + + <!-- NOTE: this test simply takes too long to complete under GC stress; it is not fundamentally incompatible --> + <GCStressIncompatible Condition="'$(Platform)' == 'x86'">true</GCStressIncompatible> </PropertyGroup> <!-- Default configurations to help VS understand the configurations --> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> diff --git a/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_r.csproj b/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_r.csproj index a7547ea0c1..909d79887a 100644 --- a/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_r.csproj +++ b/tests/src/JIT/opt/virtualstubdispatch/bigvtbl/bigvtbl_cs_r.csproj @@ -14,6 +14,9 @@ <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT .0\UITestExtensionPackages</ReferencePath> <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + + <!-- NOTE: this test simply takes too long to complete under GC stress; it is not fundamentally incompatible --> + <GCStressIncompatible Condition="'$(Platform)' == 'x86'">true</GCStressIncompatible> </PropertyGroup> <!-- Default configurations to help VS understand the configurations --> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> |